home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK2.toast / Development Kits (Disc 2) / QuickDraw GX / Programming Stuff / Sample Code / Printing Samples / Printer Drivers… / ImageWriterLQ (alt. rdip) / UniversalMessageIntf.c < prev    next >
Encoding:
Text File  |  1995-04-10  |  86.4 KB  |  2,809 lines  |  [TEXT/MPS ]
  1. /*---------------------------------------------------------------------------
  2. FILENAME
  3.     UniversalMessageIntf.c
  4.  
  5. DESCRIPTION
  6.     This file contains the routines which override the universal imaging 
  7.     messages that the ImageWriter LQ utilizes.
  8.         
  9. COPYRIGHT
  10.     Copyright Apple Computer, Inc. 1992-1994
  11.     All rights reserved. 
  12.     
  13. INTERFACE ROUTINES:
  14.     SD_Initialize
  15.     SD_ShutDown
  16.     SD_JobFormatDialog
  17.     SD_JobFormatModeQuery
  18.     SD_OpenConnection
  19.     SD_StartSendPage
  20.     SD_RenderPage
  21.     SD_DefaultPrinter
  22.     SD_SetupImageData
  23.     SD_FetchTaggedData
  24.     SD_RasterPackageBitmap
  25.     SD_RasterLineFeed
  26.  
  27.     12/20/93        dmh    Sync'd with the shipping 1.0b3 GX driver.
  28.      8/28/94        dmh    Sync'd with the shipping 1.0.1 GX driver.
  29.      8/28/94        dmh    Universalized.
  30.  
  31. -------------------------------------------------------------------------------- */
  32.  
  33. // Include the standard Mac header files 
  34. #include "MacIncludes.h"
  35.  
  36. // Include the new QuickDraw GX graphics header files 
  37. #include <graphics routines.h>
  38. #include <graphics libraries.h>
  39. #include <math routines.h>
  40. #include <qd library.h>
  41. #include <font library.h>
  42. #include <layout routines.h>
  43. #include <graphics libraries.h>
  44.  
  45. // Include the required Printing Manager header files 
  46. #include <PrintingManager.h>
  47. #include <PrintingMessages.h>
  48. #include <PrintingDrivers.h>
  49. #include <Collections.h>
  50. #include <Messages.h>
  51. #include <PrintingResTypes.h>
  52. #include <PrintingErrors.h>
  53. #include <PrintingLibraries.h>
  54.  
  55. #include <GXExceptions.h>
  56.  
  57. // Include the internal driver constants and types used by this module 
  58. #include "Resources.h"
  59. #include "UniversalMessageIntf.h"
  60. #include "OldAPIMessageIntf.h"
  61. #include "DialogRoutines.h"
  62.  
  63. /***************************************************************************************
  64. *                                                 CONSTANTS                                                         *
  65. ***************************************************************************************/                        
  66.  
  67. // ImageWriter LQ device commands
  68.  
  69. #define    kEscape                            (char) 27        // <Escape> character
  70. #define    kLineFeed                        (char) 10        // Line feed character
  71. #define    kDevStatusCommand                "\033?"            // <Escape>? - used to query the status of the printer
  72.  
  73. #define    kLowResGraphicsCommand        (char) 'G'        //    72 dpi graphics mode
  74. #define    kHighResGraphicsCommand        (char) 'C'        //    216 dpi graphics mode
  75.  
  76. #define    kLowResMarginsCommand        (char) 'F'        //    72 dpi margins command
  77. #define    kHighResMarginsCommand        (char) 'h'        //    216 dpi margins command
  78.  
  79. #define    kSetColorCommand                (char) 'K'        //    Command to select color
  80.  
  81.  
  82. // Constants used with the ScanLineRecord structure
  83.  
  84. #define    kScanLineHdrSize                15                    //    Size of the constant portion of the scan line structure
  85.  
  86.  
  87. /***************************************************************************************
  88. *                                                 TYPES                                                                 *
  89. ***************************************************************************************/                        
  90.  
  91. // ScanLineRecord -    Structure overlayed within a buffer to fill in the comands and data needed to
  92. //                            package one complete scan line.
  93. typedef struct
  94. {
  95.     char        cMarginsEscape;            // kEscape character
  96.     char        cMarginsCommand;            // Set Margins command character
  97.     char        cIndentDistance[4];        // Number of pixels to indent
  98.  
  99.     char        cColorEscape;                // kEscape character
  100.     char        cSetColorCommand;            // Set color command
  101.     char        cColor;                        // The color to use
  102.  
  103.     char        cEscape;                        // kEscape character
  104.     char        cCommand;                    // Enter graphics mode command
  105.     char        cLineStrLength[4];            // number of dots to print
  106.     char        iTheData[9072];            // Bits for the data, enough for one line's worth
  107. }    ScanLineRecord,
  108.     *ScanLinePtr;
  109.  
  110.  
  111. /***************************************************************************************
  112. *                                         INTERNAL ROUTINES                                                     *
  113. ***************************************************************************************/                        
  114.  
  115. /****************************************************************************************
  116.  
  117.                             Long2Dec
  118.                             
  119.     function:
  120.                 This routine converts a long integer into an ASCII string representing the
  121.                 numeric value.  If the number is less than four digits, then it's padded
  122.                 with leading zeros.
  123.                 
  124.     parameters:                
  125.                 theNumber            number to convert to a string
  126.                 emitStringHere        location in which to store the ASCII string
  127.                 
  128.     returns:
  129.                 none
  130.     
  131. ****************************************************************************************/
  132. void Long2Dec(long theNumber, Ptr emitStringHere)
  133. {    
  134.     char        aString[10];
  135.     short        i;
  136.     short        actualWidth;
  137.     short        theLength;
  138.     
  139.     NumToString(theNumber, aString);
  140.     
  141.     // Get the width of the string, check for being too small
  142.  
  143.     theLength = StrLength(aString);
  144.     actualWidth = theLength;
  145.     if (actualWidth < 4)
  146.         actualWidth = 4;
  147.         
  148.     // output the string, padding with leading zeros
  149.     
  150.     theLength = actualWidth - theLength;
  151.     for (i = 0; i < actualWidth; ++i)
  152.     {
  153.         *emitStringHere++ = (i < theLength) ? '0' : aString[(i + 1) - theLength];
  154.     }
  155. }
  156. /* Long2Dec */
  157.  
  158.  
  159. /****************************************************************************************
  160.  
  161.                             PrinterHasColorRibbon
  162.                             
  163.     function:
  164.                 This routine is a utility function that returns true if the desktop printer
  165.                 configuration file specifies that the printer contains a color ribbon, and
  166.                 false if it has a black and white ribbon.
  167.                 
  168.     parameters:                
  169.                 None
  170.                 
  171.     returns:
  172.                 Boolean        true => printer has color ribbon; false => black and white ribbon
  173.     
  174. ****************************************************************************************/
  175. Boolean PrinterHasColorRibbon(void)
  176. {
  177.     OSErr                        anErr;
  178.     Boolean                    hasColor = true;
  179.     Str32                        deviceName;
  180.     IWLQConfigInfoHdl        configData;
  181.     
  182.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  183.  
  184.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  185.     if ( StrLength(deviceName) > 0 )
  186.     {
  187.         // if we are going to a particular device, assume no color, as that is more common
  188.         hasColor = false;
  189.         
  190.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  191.         if (anErr == noErr)
  192.         {
  193.             hasColor = (*configData)->hasColorRibbon;
  194.             DisposHandle((Handle) configData);
  195.         }
  196.     }
  197.     
  198.     return(hasColor);
  199. }
  200. /* PrinterHasColorRibbon */
  201.  
  202.  
  203. /****************************************************************************************
  204.  
  205.                             PrinterHasTrays
  206.                             
  207.     function:
  208.                 This routine is a utility function that returns the number of sheet feeder trays
  209.                 that are attached to the desktop printer.  If no sheet feeder is attached, then 
  210.                 the function returns zero.
  211.                 
  212.     parameters:                
  213.                 None
  214.                 
  215.     returns:
  216.                 char        number of sheet feeder trays attached to the printer; zero if no sheet feeder
  217.     
  218. ****************************************************************************************/
  219. char PrinterHasTrays(void)
  220. {
  221.     OSErr                        anErr;
  222.     char                        numTrays = 0;    //    Assume no trays available (common case)
  223.     Str32                        deviceName;
  224.     IWLQConfigInfoHdl        configData;
  225.     
  226.     // if not formatting to a particular device, assume color ribbon, for widest range of colorSpaces
  227.  
  228.     GXGetPrinterName(GXGetJobOutputPrinter(GXGetJob()), deviceName);
  229.     if ( StrLength(deviceName) > 0 )
  230.     {
  231.         anErr = GXFetchDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle *) &configData);
  232.         if (anErr == noErr)
  233.         {
  234.             numTrays = (*configData)->numTrays;
  235.             DisposHandle((Handle) configData);
  236.         }
  237.     }
  238.     
  239.     return(numTrays);
  240. }
  241. /* PrinterHasTrays */
  242.  
  243.  
  244. /****************************************************************************************
  245.  
  246.                             UpdateDTPConfigInfo
  247.                             
  248.     function:
  249.                 This routine is a utility function that queries the printer to determine its
  250.                 configuration (color ribbon, trays, etc.) and updates the config info. in the
  251.                 desktop printer file to reflect this new configuration.
  252.                 
  253.     parameters:                
  254.                 None
  255.                 
  256.     returns:
  257.                 OSErr        error code
  258.     
  259. ****************************************************************************************/
  260. OSErr UpdateDTPConfigInfo(void)
  261. {
  262.     OSErr                        anErr;
  263.     IWLQConfigInfoHdl        configData;
  264.     char                        statusString[9];
  265.     long                        statusStrLength;
  266.     Boolean                    wasSheetfeederAttached;
  267.     gxJob                        theJob = GXGetJob();
  268.         
  269.     // Determine if there was a sheetfeeder attached to the printer the last time we updated the config file
  270.     wasSheetfeederAttached = PrinterHasTrays() > 0;
  271.     
  272.     // Make a handle in which to store the config. info.
  273.     
  274.     configData = (IWLQConfigInfoHdl) NewHandleClear( sizeof(IWLQConfigInfo) );
  275.     anErr = MemError();
  276.     require(anErr == noErr, NewHandleClear);
  277.     
  278.     // Now query the printer
  279.     
  280.     statusStrLength = 9;
  281.     
  282.     anErr = Send_GXGetDeviceStatus(kDevStatusCommand, 2, statusString, &statusStrLength, "\p\n");
  283.     require(anErr == noErr, Send_GXGetDeviceStatus);
  284.     
  285.     // Scan the status string returned looking for the needed info.
  286.     
  287.     if ( (statusString[0] == 'L') && (statusString[1] == 'Q') )
  288.     {
  289.         Str32        deviceName;
  290.  
  291.         if ( statusString[3] == 'C' )    //    T => Has color ribbon
  292.         {
  293.             (*configData)->hasColorRibbon = true;
  294.         }
  295.         
  296.         if (  (statusString[3] == 'E') || 
  297.                 (statusString[3] == 'F')
  298.             )                                            //    T => Sheet feeder is installed
  299.         {
  300.             (*configData)->numTrays = statusString[4] - 0x30;
  301.         }
  302.         else
  303.         if (    (statusString[4] == 'E') ||
  304.                 (statusString[4] == 'F')
  305.             )                                            //    T => Sheet feeder is installed
  306.         {
  307.             (*configData)->numTrays = statusString[5] - 0x30;
  308.         }
  309.  
  310.         //    Update the config. file with the latest info. (our driver info.)
  311.         
  312.         GXGetPrinterName(GXGetJobOutputPrinter(theJob), deviceName);
  313.         anErr = GXWriteDTPData(deviceName, kIWLQConfigType, kIWLQConfigID, (Handle) configData);
  314.         require(anErr == noErr, WriteDTPData);
  315.  
  316.         // If this is the first time we've detected a sheet feeder, then we must set the tray info. (in the config. file)
  317.         // for the sheet feeder trays.  If this isn't the first time we've detected a sheetfeeder, we'll just use
  318.         // the last sheetfeeder tray settings.
  319.         
  320.         if ( (!wasSheetfeederAttached) && ((*configData)->numTrays > 0) )    //    T => No sheetfeeder before; clear the tray info.
  321.         {
  322.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the default tray */
  323.         }
  324.         else if ( wasSheetfeederAttached && ((*configData)->numTrays == 0) )    //    T => Sheetfeeder before; clear the tray info.
  325.         {
  326.             GXSetTrayPaperType(1, NULL);    /* Reset the paper types from the first tray, ignore the others */
  327.         }
  328.     }
  329.     // else - not an LQ printer so don't change the config file info.
  330.  
  331.     // Dump the confog. data handle
  332.     DisposHandle((Handle) configData);
  333.  
  334.     return(anErr);
  335.     
  336.     
  337. /******* Clean-up *******/
  338.  
  339. WriteDTPData:
  340. Send_GXGetDeviceStatus:
  341.     DisposHandle((Handle) configData);
  342.     
  343. NewHandleClear:
  344.     return(anErr);
  345. }
  346. /* UpdateDTPConfigInfo */
  347.  
  348.  
  349. /****************************************************************************************
  350.  
  351.                             FixRoundRectangle
  352.                             
  353.     function:
  354.                 This routine is a utility function which rounds the coordinate values within 
  355.                 the rectangle passed in.
  356.                 
  357.     parameters:                
  358.                 r            rectangle whose coordinates are to be rounded
  359.                 
  360.     returns:
  361.                 None
  362.     
  363. ****************************************************************************************/
  364. void FixRoundRectangle(gxRectangle *r)
  365. {
  366.     r->top         = ff(FixRound(r->top));
  367.     r->left         = ff(FixRound(r->left));
  368.     r->bottom     = ff(FixRound(r->bottom));
  369.     r->right     = ff(FixRound(r->right));
  370. }
  371. /* FixRoundRectangle */
  372.  
  373.  
  374. /****************************************************************************************
  375.  
  376.                             JobIsBestQuality
  377.                             
  378.     function:
  379.                 This routine is called to determine if the job the driver is currently
  380.                 processing is to be output in best quality or rough quality. The function
  381.                 returns true if best quality, and false otherwise.
  382.                 
  383.     parameters:    
  384.                 None
  385.                 
  386.     returns:
  387.                 Boolean        true if best quality job; false otherwise
  388.     
  389. ****************************************************************************************/
  390. Boolean JobIsBestQuality(void)
  391. {
  392.     OSErr                    anErr;
  393.     Boolean                isFinal;
  394.     gxQualityInfo        jobQualitySettings;
  395.     long                    itemSize = sizeof(jobQualitySettings);
  396.  
  397.     // Retrieve the quality setting info from the job
  398.     anErr = GetCollectionItem(GXGetJobCollection(GXGetJob()), gxQualityTag, gxPrintingTagID, &itemSize, &jobQualitySettings);
  399.     check(anErr == noErr);
  400.     
  401.     isFinal = (anErr == noErr) && (jobQualitySettings.currentQuality == 1);
  402.  
  403.     return(isFinal);
  404. }
  405. /* JobIsBestQuality */
  406.  
  407.  
  408. /****************************************************************************************
  409.  
  410.                             MakeNewPrinterViewDevice
  411.                             
  412.     function:
  413.                 This routine is called to add a new view device to the printer object.  The
  414.                 viewDevice that's added will have a resolution of 216 dpi, and will have the
  415.                 set of colors specified by the theColors parameter.  The newly created 
  416.                 view device is added to the printer object.
  417.                 
  418.     parameters:                
  419.                 thePrinter        the newly allocated printer object
  420.                 theColors        the colors over which the view device is defined
  421.                 numColrs            the number of colors in the set
  422.                 
  423.     returns:
  424.                 OSErr
  425.                 
  426. ****************************************************************************************/
  427. OSErr MakeNewPrinterViewDevice(    gxPrinter        thePrinter,
  428.                                             gxSetColor        theColors[],
  429.                                             short                numColors)
  430. {
  431.     OSErr             anErr = noErr;
  432.     gxViewDevice     vd;
  433.     gxMapping        vdMapping;
  434.     gxShape            theBitmap;
  435.     gxColorSet        theColorSet;
  436.     
  437.     // Create the new viewDevice using a fake bitmap 
  438.     {
  439.         gxBitmap    aBitmap;
  440.         
  441.         aBitmap.pixelSize    = 1;
  442.         aBitmap.rowBytes    = 0;
  443.         aBitmap.width        = 0;
  444.         aBitmap.height        = 0;
  445.         aBitmap.image        = (char*)gxMissingImagePointer;
  446.         aBitmap.space        = gxNoSpace;
  447.         aBitmap.set            = nil;
  448.         aBitmap.profile    = nil;
  449.         
  450.         theBitmap = GXNewBitmap(&aBitmap, nil);
  451.         require_action( GXGetGraphicsError(nil) == noErr, NewBitmap, anErr = GXGetGraphicsError(nil); );
  452.         
  453.         vd = GXNewViewDevice(gxScreenViewDevices, theBitmap);
  454.         require_action( GXGetGraphicsError(nil) == noErr, NewViewDevice, anErr = GXGetGraphicsError(nil); );
  455.  
  456.         // Dispose of the reference to the temporary shape
  457.         GXDisposeShape(theBitmap);
  458.     }
  459.     
  460.     // Now set the view device's color space based on the set of colors passed in 
  461.     {
  462.         theColorSet = GXNewColorSet(gxRGBSpace, numColors, theColors);
  463.         require_action( GXGetGraphicsError(nil) == noErr, NewColorSet, anErr = GXGetGraphicsError(nil); );
  464.  
  465.         SetViewDeviceColorSet(vd, theColorSet);
  466.         require_action( GXGetGraphicsError(nil) == noErr, SetViewDeviceColorSet, anErr = GXGetGraphicsError(nil); );
  467.     
  468.         // Dispose of the reference to the temporary shape
  469.         GXDisposeColorSet(theColorSet);
  470.     }
  471.     
  472.     // Change the viewDevice mapping to include the scaling factor from 72dpi (screen) to 216 dpi (device). 
  473.     {
  474.         ResetMapping(&vdMapping);
  475.         ScaleMapping(&vdMapping, ff(3), ff(3), ff(0), ff(0));
  476.         
  477.         GXSetViewDeviceMapping(vd, &vdMapping);
  478.     }
  479.     
  480.     // Add the newly created viewDevice to the printer object 
  481.  
  482.     anErr = GXAddPrinterViewDevice(thePrinter, vd);
  483.     require_action( GXGetGraphicsError(nil) == noErr, AddPrinterViewDevice, anErr = GXGetGraphicsError(nil); );
  484.     
  485.     return(anErr);
  486.     
  487.     
  488. /******* Clean-up *******/
  489.  
  490. SetViewDeviceColorSet:
  491.     GXDisposeColorSet(theColorSet);
  492.  
  493. AddPrinterViewDevice:
  494. NewColorSet:
  495.     GXDisposeViewDevice(vd);
  496.     return(anErr);
  497.  
  498. NewViewDevice:
  499.     GXDisposeShape(theBitmap);
  500.  
  501. NewBitmap:
  502.     return(anErr);
  503. }
  504. /* MakeNewPrinterViewDevice */
  505.  
  506.  
  507. /****************************************************************************************
  508.  
  509.                             WriteDraftChars
  510.                             
  511.     function:
  512.                 This routine is called to output a single character in the native set of the
  513.                 printer.  The draftTable parameter contains long word entries for each possible
  514.                 character that can be printed.  Each long word entry is composed of two word entries,
  515.                 where the first word represents the primary character to output and the second
  516.                 word optionally specifies an overstrike character.  If an overstrike character
  517.                 is specified, then we will overstrike the second character on the first.  The format
  518.                 of each word is the same and is as follows:
  519.                 
  520.                 bit 15         -    0 => don't backspace before writing character
  521.                                     1 => backspace first before printing the character
  522.                 
  523.                 bits 14:12    -    0
  524.  
  525.                 bits 11:8    -    national character set to invoke (e.g. kAmerican)
  526.  
  527.                 bits 7:0        -    the character to send to the printer (must be != 0 to be output)
  528.                 
  529.     parameters:    
  530.                 draftTable        Handle to an array of long word entries that describe how to output
  531.                                     each printable character in draft mode
  532.                 draftChar        Pointer to the ASCII characters that are to be output
  533.                 numChars            Number of characters to be output
  534.                 
  535.     returns:
  536.                 OSErr
  537.     
  538. ****************************************************************************************/
  539. OSErr WriteDraftChars(long **draftTable, unsigned char *draftChar, long numChars)
  540. {
  541.     OSErr        anErr = noErr;
  542.     char        outputChars[20];                // a maximum of 20 characters can be generated
  543.     short        charCount;                    
  544.     
  545.     // For each character in the buffer, determine how to map the character to a draft character
  546.     for (; numChars > 0; --numChars, ++draftChar)
  547.     {
  548.         // No characters yet for this output character
  549.         charCount = 0;
  550.             
  551.         // Only consider characters in the printable range
  552.         if (*draftChar >= 0x20)
  553.         {
  554.             unsigned long    draftControl = (*draftTable)[*draftChar-0x20];    // Fetch native mode long word corresponding to this character
  555.             unsigned char    outChar;
  556.             unsigned char    nationalSet;
  557.             short                i;
  558.             
  559.             // For each word which composes the native mode long word 
  560.             for (i = 1; i >= 0; --i)
  561.             {
  562.                 // Should we send a backspace character (to overstrike)?
  563.                 if ( (draftControl & 0x80000000) != 0 )
  564.                     outputChars[charCount++] = 0x08;
  565.                 
  566.                 outChar = (draftControl >> 16) & 0xFF;
  567.                 if (outChar != 0)
  568.                 {
  569.                     // Determine the national character set to select
  570.                     nationalSet = (draftControl >> 24) & 0xF;    
  571.     
  572.                     //    Is this character in the standard, built-in character set?
  573.                     if (nationalSet == kAmerican)
  574.                     {
  575.                         outputChars[charCount++] = outChar;
  576.                     }
  577.                     else    //    T => Must select a foreign language character set 
  578.                     {
  579.                         outputChars[charCount++] = 0x1B;
  580.                         outputChars[charCount++] = 0x44;
  581.                         outputChars[charCount++] = nationalSet;
  582.                         outputChars[charCount++] = 0x00;
  583.                         outputChars[charCount++] = outChar;
  584.                         outputChars[charCount++] = 0x1B;                // We always switch back to the kAmerican character set
  585.                         outputChars[charCount++] = 0x5A;
  586.                         outputChars[charCount++] = 0x07;
  587.                         outputChars[charCount++] = 0x00;
  588.                     }
  589.                 }
  590.                 
  591.                 // Take the next (low) word and process it (if we're not all done)
  592.                 draftControl <<= 16;
  593.             }    
  594.         }
  595.             
  596.         // If we generated any data, send it out now
  597.         if (charCount > 0)
  598.             anErr = Send_GXBufferData(outputChars, charCount, gxNoBufferOptions);
  599.     }
  600.         
  601.     return(anErr);    
  602.     
  603. } 
  604. /* WriteDraftChars */
  605.  
  606.  
  607. /****************************************************************************************
  608.  
  609.                             GetPointerThisBig
  610.                             
  611.     function:
  612.                 This routine is called to return a pointer (in the heap) to the number of
  613.                 bytes specified by numBytes.  If the pointer is already large enough, then
  614.                 this routine simply returns the existing pointer.  Otherwise, it allocates
  615.                 a new pointer (possibly disposing of the old one) of the specified size.
  616.                 
  617.     parameters:    
  618.                 theBuff            returns a pointer to the allocated buffer 
  619.                 numBytes            required size of the pointer returned (in bytes)
  620.                 
  621.     returns:
  622.                 OSErr
  623.     
  624. ****************************************************************************************/
  625. OSErr GetPointerThisBig(Ptr *theBuff, long numBytes) 
  626. {
  627.     OSErr        anErr = noErr;
  628.     
  629.     if (*theBuff != nil)
  630.     {
  631.         if ( GetPtrSize(*theBuff) < numBytes )    //    T => Won't be big enough; make a new one
  632.         {
  633.             DisposPtr(*theBuff);
  634.             *theBuff = nil;
  635.         }
  636.     }
  637.  
  638.     if (*theBuff == nil)
  639.     {
  640.         *theBuff = NewPtrClear(numBytes);
  641.         anErr = MemError();
  642.     }
  643.     
  644.     return(anErr);
  645. }
  646. /* GetPointerThisBig */
  647.  
  648.  
  649. /****************************************************************************************
  650.  
  651.                             GetTextAndPosition
  652.                             
  653.     function:
  654.                 This routine is called to return information about the layout shape
  655.                 referenced by the theShape parameter.  It returns a pointer to the
  656.                 text data in theChars, the number of characters in the data in numChars, and
  657.                 a pointer to the positions of the characters in textPositions.  The caller
  658.                 is responsible for disposing of the pointers returned in theChars and
  659.                 textPositions.
  660.                 
  661.     parameters:    
  662.                 theShape            reference to the shape to be examined
  663.                 theChars            returns a pointer to the text characters
  664.                 numChars            returns the number of characters in the text shape
  665.                 textPosition    returns the position of the layout shape
  666.                 
  667.     returns:
  668.                 OSErr
  669.     
  670. ****************************************************************************************/
  671. OSErr GetTextAndPosition(    gxShape            theShape, 
  672.                                     Ptr            *theChars, 
  673.                                     long            *numChars, 
  674.                                     gxPoint            *textPosition)
  675. {
  676.     OSErr        anErr = noErr;
  677.     long        textStrLength;
  678.     
  679.     // Determine the size of the text data and the position of the text
  680.     textStrLength = GXGetLayout(theShape, nil, nil, nil, nil, nil, nil, nil, nil, textPosition);
  681.  
  682.     // Make sure we have a buffer pointer large enough to hold all of the data
  683.     
  684.     anErr = GetPointerThisBig(theChars, textStrLength);
  685.     require(anErr == noErr, CantAllocTextBuff);
  686.     
  687.     // Now we retrieve the text
  688.     GXGetLayout(theShape, *theChars, nil, nil, nil, nil, nil, nil, nil, nil);
  689.     
  690.     // Remember the number of characters in the shape
  691.     *numChars = textStrLength;
  692.     
  693.  
  694. /******* Clean-up *******/
  695.  
  696. CantAllocTextBuff:
  697.     return(anErr);
  698. }
  699. /* GetTextAndPosition */
  700.  
  701.  
  702. /****************************************************************************************
  703.  
  704.                             PrintPageInDraftMode
  705.                             
  706.     function:
  707.                 This routine is called to print a page using the native character set in the
  708.                 printer.  The page to print is referenced by the thePage parameter.  The routine
  709.                 walks through the picture looking for layout shapes.  Each of these
  710.                 shapes is imaged using the native character set; all other shapes are ignored.
  711.                 This routine assumes the shapes within the picture are y-sorted.
  712.                 
  713.     parameters:    
  714.                 thePage        Reference to the page shape that's to be printed
  715.                 imageData    pointer to the raster image data
  716.                 
  717.     returns:
  718.                 OSErr
  719.     
  720. ****************************************************************************************/
  721. OSErr PrintPageInDraftMode(gxShape thePage, gxRasterImageDataHdl imageData)
  722. {
  723.     OSErr                    anErr = noErr;
  724.     long                    i;
  725.     long                    numItems;
  726.     Fixed                    currYPos = ff(0);
  727.     Ptr                    theChars = nil;
  728.     long                    numChars = 0;
  729.     gxPoint                textPosition;
  730.     Fixed                    oldTextSize = ff(0);
  731.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  732.     
  733.     // Since the page picture we need to process is a picture shape that's embedded in
  734.     // thePage (a shape containing one item => a picture), we need to extract the real
  735.     // page picture from thePage.
  736.     
  737.     thePage = GetPictureItem(thePage, 1, nil, nil, nil, nil);
  738.     numItems = GXGetPicture(thePage, nil, nil, nil, nil);
  739.     
  740.     // For each shape within the picture, check its type and process it accordingly
  741.     
  742.     for (i = 1; i <= numItems; ++i)
  743.     {
  744.         gxShape                theShape;
  745.         short                    theType;
  746.         
  747.         theShape = GetPictureItem(thePage, i, nil, nil, nil, nil);
  748.         theType = GXGetShapeType(theShape);
  749.         
  750.         if (theType == gxLayoutType)    //    T => We have a layout shape
  751.         {
  752.             fixed        textSize;
  753.             char        buff[12];
  754.             char        theFace;
  755.             short        cmndBuffSz;
  756.             
  757.             // First determine the style in which we're printing
  758.             
  759.             theFace = GetStyleCommonFace( GXGetShapeStyle(theShape) );
  760.             
  761.             buff[0] = kEscape;
  762.             if ( (theFace & bold) != 0 )    //    T => Turn bold facing on
  763.                 buff[1] = '!';
  764.             else                                    //    T => Turn it off
  765.                 buff[1] = '"';
  766.             
  767.             buff[2] = kEscape;
  768.             if ( (theFace & underline) != 0 )    //    T => Turn underline facing on
  769.                 buff[3] = 'X';
  770.             else                                            //    T => Turn it off
  771.                 buff[3] = 'Y';
  772.                 
  773.             cmndBuffSz = 4;
  774.             
  775.             // Next determine if we need to change the size of the font being used
  776.             
  777.             textSize = GXGetShapeTextSize(theShape);
  778.             if (textSize != oldTextSize)    //    T => Must issue LQ command to change font size
  779.             {
  780.                 buff[4] = kEscape;                //    The first escape command selects black color
  781.                 buff[5] = kSetColorCommand;
  782.                 buff[6] = '0';
  783.                 
  784.                 buff[7] = kEscape;                //    The second escape command selects a draft font
  785.                 buff[8] = 'a';
  786.                 buff[9] = '1';
  787.                 
  788.                 buff[10] = kEscape;                //    The third escape command selects the character pitch
  789.                 
  790.                 if ( textSize <= ff(10) )    //    T => Select 10 cpi
  791.                 {
  792.                     buff[11] = 'N';
  793.                 }
  794.                 else    //    T => All other sizes get mapped to 12 cpi
  795.                 {
  796.                     buff[11] = 'E';
  797.                 }
  798.                 
  799.                 // Remember the last text size
  800.                 oldTextSize = textSize;    
  801.                 
  802.                 // Adjust the size of the data to be sent to the printer
  803.                 cmndBuffSz += 8;
  804.             }
  805.             // else - no change in font size
  806.             
  807.             // Send the commands to the printer
  808.             anErr = Send_GXBufferData(buff, cmndBuffSz, gxDontSplitBuffer);
  809.             require(anErr == noErr, CantSendFontCmnd);
  810.  
  811.             // Get the ASCII text and the starting position of the data
  812.             anErr = GetTextAndPosition(theShape, &theChars, &numChars, &textPosition);
  813.             require(anErr == noErr, CantGetTextAndPos);
  814.             
  815.             if ( (currYPos != ff(0)) && (currYPos != textPosition.y) )    //    T => Moving to a lower line, finish the last ;line with a CR
  816.             {
  817.                 char        c = 0x0D;
  818.                 
  819.                 anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  820.                 require(anErr == noErr, CantSendCRCmnd);
  821.             }
  822.             
  823.             // Position the print head to the proper location on the page
  824.             {
  825.                 gxMapping            theMapping;
  826.                 short                    lineFeedSize;
  827.                 Str255                positionCmndsBuff;
  828.                 unsigned long        bytesInBuff = 0;
  829.                 char                    *p;
  830.  
  831.                 GXGetShapeMapping(theShape, &theMapping);
  832.                 MapPoints(&theMapping, (long) 1, &textPosition);    //    Just map the first point
  833.                 
  834.                 // Now position the print head vertically
  835.  
  836.                 lineFeedSize = (textPosition.y - currYPos) >> 16;
  837.                 anErr = Send_GXRasterLineFeed(&lineFeedSize, positionCmndsBuff, &bytesInBuff, imageData);
  838.                 require(anErr == noErr, CantEmitLineFeeds);
  839.                 
  840.                 // Update the current Y position pointer on the page
  841.                 currYPos = textPosition.y;
  842.  
  843.                 // Now position the print head horizontally on the page
  844.  
  845.                 p = &positionCmndsBuff[bytesInBuff];        
  846.                 *p++ = kEscape;
  847.                 *p++ = kLowResMarginsCommand;
  848.                 Long2Dec((*hGlobals)->leftMargin + FixedToInt(textPosition.x), p);    // Convert left margin into ASCII and place it at the start of the scan line
  849.                 
  850.                 // Update the number of bytes in the buffer
  851.                 bytesInBuff += 6;
  852.  
  853.                 // Send the positioning info to the printer
  854.                 anErr = Send_GXBufferData(positionCmndsBuff, bytesInBuff, gxDontSplitBuffer);
  855.                 require(anErr == noErr, CantSendPositionCmnds);
  856.             }
  857.             
  858.             // Now we send the text data to the printer
  859.             anErr = WriteDraftChars((long **) (*hGlobals)->draftTable, theChars, numChars);
  860.             require(anErr == noErr, CantWriteChars);
  861.         }
  862.     }    // for
  863.  
  864.     // Send one last CR to wrap the last line (if there was one)
  865.     {
  866.         char        c = 0x0D;
  867.         
  868.         anErr = Send_GXBufferData(&c, 1, gxNoBufferOptions);
  869.     }
  870.  
  871.  
  872. /******* Clean-up *******/
  873.  
  874. CantWriteChars:
  875. CantSendPositionCmnds:
  876. CantEmitLineFeeds:
  877. CantSendCRCmnd:
  878. CantGetTextAndPos:
  879. CantSendFontCmnd:
  880.     if (theChars != nil)
  881.         DisposPtr(theChars);
  882.                 
  883.     return(anErr);
  884. }
  885. /* PrintPageInDraftMode */
  886.  
  887.  
  888. /***************************************************************************************
  889. *                                         INTERFACE ROUTINES                                                     *
  890. ***************************************************************************************/                        
  891.  
  892. /****************************************************************************************
  893.  
  894.                             SD_Initialize
  895.                             
  896.     function:
  897.                 This routine is called when a new job is created to perform some job-oriented
  898.                 task, such as conducting dialogs, spooling, and imaging.  It allocates the
  899.                 driver's globals handle and initializes it.
  900.                 
  901.     parameters:    
  902.                 None
  903.                 
  904.     returns:
  905.                 OSErr
  906.     
  907. ****************************************************************************************/
  908. OSErr SD_Initialize(void)
  909. {
  910.     OSErr                 anErr;
  911.     SpecGlobalsHdl     hGlobals;
  912.     
  913.     // Allocate the driver's global handle 
  914.  
  915.     hGlobals = (SpecGlobalsHdl) NewHandleClear(kSpecGlobalsRecLen);
  916.     anErr = MemError();
  917.     require(anErr == noErr, NewHandleClear);
  918.     
  919.     // Tell the Printing Manager to save our globals handle for us 
  920.     SetMessageHandlerInstanceContext(hGlobals);
  921.  
  922.     return(anErr);
  923.     
  924.     
  925. /******* Clean-up *******/
  926.  
  927. NewHandleClear:
  928.     return(anErr);
  929. }
  930. /* SD_Initialize */
  931.  
  932.  
  933. /****************************************************************************************
  934.  
  935.                             SD_ShutDown
  936.                             
  937.     function:
  938.                 This routine is called when a job-oriented task has completed and the 
  939.                 message chain is being destroyed.  This routine disposes of the driver's
  940.                 globals handle..
  941.                 
  942.     parameters:        
  943.                 None
  944.                 
  945.     returns:
  946.                 OSErr
  947.     
  948. ****************************************************************************************/
  949. OSErr SD_ShutDown(void)
  950. {
  951.     SpecGlobalsHdl hGlobals = GetMessageHandlerInstanceContext();
  952.     
  953.     // Dump the draft table if we loaded it
  954.     if ( (*hGlobals)->draftTable != nil )
  955.         DisposHandle((*hGlobals)->draftTable);
  956.     
  957.     // Dump the driver's globals handle if it was allocated 
  958.     if (hGlobals != nil)
  959.         DisposHandle((Handle) hGlobals);
  960.  
  961.     // Make sure the Printing Manager no longer has a reference to our globals handle 
  962.     SetMessageHandlerInstanceContext(nil);
  963.         
  964.     return(noErr);
  965. }
  966. /* SD_ShutDown */
  967.  
  968.  
  969. /****************************************************************************************
  970.  
  971.                             SD_JobFormatDialog
  972.                             
  973.     function:
  974.                 This routine is called when the Printing Manager is called to display the
  975.                 Job Format dialog.  This message gives the driver the opportunity to determine
  976.                 the job format modes that are supported by the application.  If the application
  977.                 supports text, then we set the preferred job format mode to be 'text'.  The preferred
  978.                 format mode is the format mode that becomes active when the user selects Direct
  979.                 Mode from the Job Format dialog box.
  980.                 
  981.     parameters:                
  982.                 dlgResult        result of dismissing the dialog (ok or cancel)
  983.                 
  984.     returns:
  985.                 OSErr
  986.                 
  987. ****************************************************************************************/
  988. OSErr SD_JobFormatDialog(gxDialogResult *dlgResult)
  989. {
  990.     OSErr                         anErr;
  991.     gxJobFormatModeTableHdl    theJobFormatModeList;
  992.     gxJob                             theJob = GXGetJob();
  993.     
  994.     // Did the application specify any job format modes?
  995.     
  996.     anErr = GXGetAvailableJobFormatModes(&theJobFormatModeList);
  997.     if ( (anErr == noErr) && (theJobFormatModeList != nil) )
  998.     {
  999.         long    i;
  1000.  
  1001.         // Examine each job format mode to determine if 'text' mode is supported.  If
  1002.         // it is, then we make it the preferred format mode for Direct Mode printing
  1003.         
  1004.         for (i = 0; i <= (*theJobFormatModeList)->numModes - 1; ++i) 
  1005.         {
  1006.             if ((*theJobFormatModeList)->modes[i] == gxTextJobFormatMode) 
  1007.             {
  1008.                 // Tell Printing Manger we support 'text' Direct Mode, but that we also
  1009.                 // support other modes.
  1010.                 
  1011.                 GXSetPreferredJobFormatMode(gxTextJobFormatMode, false);
  1012.                 break;
  1013.             }
  1014.         }
  1015.         
  1016.         // Dump the temporary handle we were issued
  1017.         DisposHandle((Handle)theJobFormatModeList);
  1018.     }
  1019.         
  1020.     // New we let the dialog be displayed. 
  1021.  
  1022.     anErr = Forward_GXJobDefaultFormatDialog(dlgResult);
  1023.     require(anErr == noErr, Forward_GXJobFormatDialog);
  1024.     
  1025.     return(anErr);
  1026.     
  1027.     
  1028. /******* Clean-up *******/
  1029.  
  1030. Forward_GXJobFormatDialog:
  1031.     return(anErr);
  1032. }
  1033. /* SD_JobFormatDialog */
  1034.  
  1035.  
  1036. /****************************************************************************************
  1037.  
  1038.                             SD_JobPrintDialog
  1039.                             
  1040.     function:
  1041.                 This routine is called when the Printing Manager is called to display the
  1042.                 Job dialog.  This message gives the driver the opportunity to add the LQ Options
  1043.                 panel to the dialog.  This panel provides the user the option to choose between
  1044.                 bidirectional and unidirectional printing.
  1045.                 
  1046.     parameters:                
  1047.                 dlgResult        result of dismissing the dialog (ok or cancel)
  1048.                 
  1049.     returns:
  1050.                 OSErr
  1051.                 
  1052. ****************************************************************************************/
  1053. OSErr SD_JobPrintDialog(gxDialogResult *dlgResult)
  1054. {
  1055.     OSErr                     anErr;
  1056.     gxPanelSetupRecord    thePanelInfo;
  1057.     long                        headMotionSize;
  1058.     Collection                jobCollection;
  1059.     HeadMotionJobItem        theMotion;
  1060.         
  1061.     // Get a reference to the job's collection
  1062.     jobCollection = GXGetJobCollection( GXGetJob() );
  1063.     
  1064.     // See if the head motion collection item exists.  It the item already exists, then
  1065.     // we'll use the last settings.
  1066.  
  1067.     headMotionSize = sizeof(HeadMotionJobItem);
  1068.     anErr = GetCollectionItem (jobCollection,
  1069.                                         kDrvrCreatorType, 
  1070.                                         kHeadMotionItemIndex, 
  1071.                                            &headMotionSize,
  1072.                                            &theMotion);
  1073.                                         
  1074.     if (anErr == collectionItemNotFoundErr)    // T => Item doesn't exist; add it
  1075.     {
  1076.         theMotion.direction = doUnidirectional;
  1077.         
  1078.         anErr = AddCollectionItem(    jobCollection, 
  1079.                                             kDrvrCreatorType, 
  1080.                                             kHeadMotionItemIndex, 
  1081.                                             sizeof(HeadMotionJobItem),
  1082.                                             &theMotion);
  1083.         require(anErr == noErr, AddCollectionItem);
  1084.     }
  1085.     else
  1086.         require(anErr == noErr, CantGetCollection);
  1087.  
  1088.     // Before allowing the Printing Manager to display the dialog, we must first add
  1089.     // our panel to the dialog.  We do this by appropriately filling in the PanelSetupRecord
  1090.     // and then telling the Printing Manager to add our panel to the dialog.
  1091.     
  1092.     // Initialize the dialog panel structure
  1093.     thePanelInfo.panelResId            = kLQOptionsPanl;        //    Resource ID of the 'panl' resource
  1094.     thePanelInfo.resourceRefNum    = GXGetMessageHandlerResFile();
  1095.     thePanelInfo.refCon                = 0;
  1096.     thePanelInfo.panelKind            = gxDriverPanel;
  1097.     
  1098.     // Add the dialog panel to the Print dialog
  1099.     
  1100.     GXSetupDialogPanel(&thePanelInfo);
  1101.     anErr = GXGetJobError( GXGetJob() );
  1102.     require(anErr == noErr, SetupDialogPanel);
  1103.  
  1104.     // Now we let the dialog be displayed. 
  1105.  
  1106.     anErr = Forward_GXJobPrintDialog(dlgResult);
  1107.     check(anErr == noErr);
  1108.     
  1109.     
  1110. /******* Clean-up *******/
  1111.  
  1112. Forward_GXJobPrintDialog:
  1113. SetupDialogPanel:
  1114. CantGetCollection:
  1115. AddCollectionItem:
  1116.     return(anErr);
  1117. }
  1118. /* SD_JobPrintDialog */
  1119.  
  1120.  
  1121. /****************************************************************************************
  1122.  
  1123.                             SD_JobFormatModeQuery
  1124.                             
  1125.     function:
  1126.                 This routine is called when an application calls JobFormatModeQuery to determine
  1127.                 the format modes that are available from the driver.  This message gives the 
  1128.                 driver the opportunity to determine the type of format mode query the driver
  1129.                 is requesting and responds to it with the appropriate data.
  1130.                 
  1131.     parameters:                
  1132.                 theQuery        type of query to perform
  1133.                 srcData        source data (varies depending upon the type of query)
  1134.                 dstData        destination data (varies depending upon the type of query)
  1135.                 
  1136.     returns:
  1137.                 OSErr
  1138.                 
  1139. ****************************************************************************************/
  1140. OSErr SD_JobFormatModeQuery(gxQueryType theQuery, void *srcData, void *dstData)
  1141. {
  1142.     OSErr        anErr = noErr;
  1143.     Handle    theFonts;
  1144.     Handle    theStyles;
  1145.     
  1146.     check(dstData != nil);
  1147.     
  1148.     // What type of query is being requested?
  1149.     switch(theQuery) 
  1150.     {
  1151.         case gxSetStyleJobFormatCommonStyleQuery:
  1152.         {
  1153.             char                *pStyleName;
  1154.  
  1155.             // Fetch the list of supported styles
  1156.             
  1157.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1158.             require(anErr == noErr, FailedToLoadStyles1);
  1159.             
  1160.             HNoPurge(theStyles);
  1161.             HLock(theStyles);
  1162.             
  1163.             // Determine which style is being referenced and set the corresponding style (only 2 styles
  1164.             // are currently supported)
  1165.             
  1166.             if (**((short **) theStyles) == 2)    //    T => We have the correct number of styles
  1167.             {
  1168.                 char        whichFace = 0;
  1169.                 
  1170.                 pStyleName = ((char *) *theStyles) + sizeof(short); 
  1171.                 
  1172.                 if ( IUCompString(pStyleName, (char *) srcData) == 0 )    //    T => They want bold face
  1173.                 {
  1174.                     whichFace = bold;
  1175.                 }
  1176.                 else
  1177.                 {
  1178.                     // Point to the next name in the list
  1179.                     pStyleName += *pStyleName + 1;
  1180.  
  1181.                     if ( IUCompString(pStyleName, (char *) srcData) == 0 )    //    T => They want underline face
  1182.                     {
  1183.                         whichFace = underline;
  1184.                     }
  1185.                 }
  1186.  
  1187.                 //    If the client specified a valid face, set it now
  1188.                 if (whichFace != 0)
  1189.                 {
  1190.                     SetStyleCommonFace((gxStyle) dstData, GetStyleCommonFace((gxStyle) dstData) | whichFace);
  1191.                 }
  1192.             }
  1193.             // else - something is wrong with our resource
  1194.             
  1195.             // Dump the temporary handle
  1196.             DisposHandle(theStyles);
  1197.             
  1198.             break;
  1199.         }
  1200.             
  1201.         case gxGetJobFormatFontCommonStylesQuery:
  1202.         {
  1203.             short                numStyles;
  1204.             short                i;
  1205.             char                *pStyleName;
  1206.  
  1207.             // Fetch the list of supported styles
  1208.             
  1209.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeStylesID, &theStyles);
  1210.             require(anErr == noErr, FailedToLoadStyles2);
  1211.             
  1212.             HNoPurge(theStyles);
  1213.             HLock(theStyles);
  1214.             
  1215.             // Determine the number of styles in the list
  1216.             numStyles = **((short **) theStyles);
  1217.  
  1218.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the styles
  1219.                 SetHandleSize(*(Handle *)dstData, sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1220.             else
  1221.                 *(Handle *)dstData = NewHandle(sizeof(gxStyleNameTable) + ((numStyles - 1) * sizeof(Str255)));
  1222.             
  1223.             anErr = MemError();
  1224.             require(anErr == noErr, StyleTableResizeFailed);
  1225.             
  1226.             // Now extract the name of each of the supported fonts
  1227.             
  1228.             for (i = 1, pStyleName = ((char *) *theStyles) + sizeof(short); i <= numStyles; ++i, pStyleName += *pStyleName + 1)
  1229.             {
  1230.                 BlockMove(pStyleName, (*((gxStyleNameTableHdl) *(Handle *)dstData))->styleNames[i - 1], *pStyleName + 1);
  1231.             }
  1232.             
  1233.             (*((gxStyleNameTableHdl) *(Handle *)dstData))->numStyleNames = numStyles;
  1234.             
  1235.             // Dump the temporary handle
  1236.             DisposHandle(theStyles);
  1237.             
  1238.             break;
  1239.         }
  1240.             
  1241.         case gxGetJobFormatLineConstraintQuery:            //    This type of query is not supported
  1242.             if (*(Handle *)dstData != nil)
  1243.                 SetHandleSize(*(Handle *)dstData, 0);        // Don't return any data
  1244.             break;
  1245.             
  1246.         case gxGetJobFormatFontsQuery:
  1247.         {
  1248.             short                numFonts;
  1249.             short                i;
  1250.             char                *pFontName;
  1251.  
  1252.             // Fetch the list of supported fonts
  1253.             
  1254.             anErr = Send_GXFetchTaggedDriverData('STR#', kFormatModeFontsID, &theFonts);
  1255.             require(anErr == noErr, FailedToLoadFonts);
  1256.             
  1257.             HNoPurge(theFonts);
  1258.             HLock(theFonts);
  1259.             
  1260.             // Determine the number of fonts in the list
  1261.             numFonts = **((short **) theFonts);
  1262.  
  1263.             if (*(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on the fonts
  1264.                 SetHandleSize(*(Handle *)dstData, sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1265.             else
  1266.                 *(Handle *)dstData = NewHandle(sizeof(gxFontTable) + ((numFonts - 1) * sizeof(gxFont)));
  1267.             
  1268.             anErr = MemError();
  1269.             require(anErr == noErr, FontTableResizeFailed);
  1270.             
  1271.             // Now generate a reference to each of the supported fonts
  1272.             
  1273.             for (i = 1, pFontName = ((char *) *theFonts) + sizeof(short); i <= numFonts; ++i, pFontName += *pFontName + 1)
  1274.             {
  1275.                 gxFont            thisFont;
  1276.                 gxFontTable    *pFontTable;
  1277.             
  1278.                 thisFont = FindPNameFont(gxFullFontName, pFontName);
  1279.                 
  1280.                 pFontTable = *((gxFontTableHdl) *(Handle *)dstData);
  1281.                 pFontTable->fonts[i - 1] = thisFont;
  1282.             }
  1283.             
  1284.             (*((gxFontTableHdl) *(Handle *)dstData))->numFonts = numFonts;
  1285.             
  1286.             // Dump the temporary handle
  1287.             DisposHandle(theFonts);
  1288.  
  1289.             break;
  1290.         }
  1291.             
  1292.         case gxGetJobFormatFontConstraintQuery:
  1293.         {
  1294.             gxPositionConstraintTable        *pPositionTable;
  1295.             
  1296.             if ( *(Handle *)dstData != nil)    //    T => Resize the handle to hold info. on position constraints
  1297.                 SetHandleSize(*(Handle *)dstData, sizeof(gxPositionConstraintTable) + sizeof(Fixed));
  1298.             else
  1299.                 *(Handle *)dstData = NewHandle( sizeof(gxPositionConstraintTable) + sizeof(Fixed) );
  1300.             
  1301.             pPositionTable = *((gxPositionConstraintTableHdl) *(Handle *)dstData);
  1302.             
  1303.             pPositionTable->phase.x     = 0;                //    Start at the top left corner of the page
  1304.             pPositionTable->phase.y     = 0;
  1305.             pPositionTable->offset.x     = ff(12);        // Indent from the top left by a six lines per inch margin
  1306.             pPositionTable->offset.y     = ff(12);         
  1307.             pPositionTable->numSizes     = 2;                // Two font sizes supported
  1308.             pPositionTable->sizes[0]     = ff(10);         // 10 pitch
  1309.             pPositionTable->sizes[1]     = ff(12);         // 12 pitch
  1310.             
  1311.             break;
  1312.         }
  1313.     } // switch
  1314.     
  1315.     return(anErr);
  1316.     
  1317.  
  1318. /******* Clean-up *******/
  1319.  
  1320. StyleTableResizeFailed:
  1321.     DisposHandle((Handle) theStyles);
  1322.     return(anErr);
  1323.  
  1324. FontTableResizeFailed:
  1325.     DisposHandle((Handle) theFonts);
  1326.  
  1327. FailedToLoadStyles1:
  1328. FailedToLoadStyles2:
  1329. FailedToLoadFonts:
  1330.     return(anErr);
  1331. }
  1332. /* SD_JobFormatModeQuery */
  1333.  
  1334.  
  1335. /****************************************************************************************
  1336.  
  1337.                             SD_OpenConnection
  1338.                             
  1339.     function:
  1340.                 This routine is called when the Printing Manager sends the OpenConnection
  1341.                 message.  We take this opportunity to open a connection to the printer and
  1342.                 query the printer to determine its configuration (e.g. color ribbon, trays, etc.).
  1343.                 We then save the configuration information in the desktop printer file.
  1344.                 
  1345.     parameters:        
  1346.                 None
  1347.                 
  1348.     returns:
  1349.                 OSErr
  1350.     
  1351. ****************************************************************************************/
  1352. OSErr SD_OpenConnection(void)
  1353. {
  1354.     OSErr                anErr;
  1355.  
  1356.     // Try to open the connection
  1357.     
  1358.     anErr = Forward_GXOpenConnection();
  1359.     require(anErr == noErr, Forward_GXOpenConnection);
  1360.     
  1361.     // Query the printer so we can update the configuration information
  1362.     
  1363.     anErr = UpdateDTPConfigInfo();
  1364.     require(anErr == noErr, UpdateDTPConfigInfo);
  1365.     
  1366.     return(anErr);
  1367.     
  1368.     
  1369. /******* Clean-up *******/
  1370.  
  1371. UpdateDTPConfigInfo:
  1372.     Send_GXCleanupOpenConnection();
  1373.     
  1374. Forward_GXOpenConnection:
  1375.     return(anErr);
  1376. }
  1377. /* SD_OpenConnection */
  1378.  
  1379.  
  1380. /****************************************************************************************
  1381.  
  1382.                             SD_CleanupOpenConnection
  1383.                             
  1384.     function:
  1385.                 This routine is called when the Printing Manager sends the CleanupOpenConnection
  1386.                 message.  It's initiated by our SD_OpenConnection routine when we cannot query
  1387.                 the printer after opening the connection.  We simply forward the message along to
  1388.                 allow others in the message chain to cleanup.
  1389.                 
  1390.     parameters:        
  1391.                 None
  1392.                 
  1393.     returns:
  1394.                 OSErr
  1395.     
  1396. ****************************************************************************************/
  1397. void SD_CleanupOpenConnection(void)
  1398. {
  1399.     // Just forward along the message
  1400.     Forward_GXCleanupOpenConnection();
  1401. }
  1402. /* SD_CleanupOpenConnection */
  1403.  
  1404.  
  1405. /****************************************************************************************
  1406.  
  1407.                             SD_StartSendPage
  1408.                             
  1409.     function:
  1410.                 This routine is called by the Printing Manager to signal the start of sending
  1411.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1412.                 to make sure the paper is in the printer.  If the printer has trays attached,
  1413.                 then this routine determines from which tray to feed the paper and then sends
  1414.                 the appropriate tray selection command to the printer.  The tray to pull the
  1415.                 paper from has already been determined by this time by the Universal Driver.
  1416.                 The Job collection contains the index of the tray to pull from.
  1417.                 
  1418.     parameters:                
  1419.                 pageFormat        format for the page to print
  1420.  
  1421.     returns:
  1422.                 OSErr
  1423.     
  1424. ****************************************************************************************/
  1425. OSErr SD_StartSendPage (gxFormat pageFormat)
  1426. {
  1427.     OSErr                    anErr;
  1428.     Collection            jobCollection;
  1429.     gxStatusRecord        *pStatus;
  1430.     gxTrayFeedInfo        trayFeedInfo;
  1431.     long                    itemSize = sizeof(trayFeedInfo);
  1432.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1433.     
  1434.     // Get a reference to the job's collection
  1435.     jobCollection = GXGetJobCollection( GXGetJob() );
  1436.     
  1437.     // Determine if this is a manual feed page 
  1438.  
  1439.     anErr = GetCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, &itemSize, &trayFeedInfo);
  1440.     nrequire(anErr, GetCollectionItem);
  1441.     
  1442.     if (trayFeedInfo.manualFeedThisPage)    //    T => Alert the user to place the paper into the printer
  1443.     {
  1444.         gxManualFeedRecord    *mfeedInfo;
  1445.         gxPaperType                thePaperType;
  1446.  
  1447.         // Wait for all IO to complete, so that we can correctly tell the user what to do.
  1448.         // Since the WriteData message makes sure all data is flushed before performing the
  1449.         // IO, this call insures that pending IO is complete.
  1450.  
  1451.         anErr = Send_GXWriteData(nil, 0);
  1452.         nrequire(anErr, FlushAllData);
  1453.  
  1454.         // Now we set-up to alert the user to put paper into the printer
  1455.     
  1456.         pStatus = (gxStatusRecord *) NewPtrClear(sizeof(gxStatusRecord) + sizeof(gxManualFeedRecord));
  1457.         anErr = MemError();
  1458.         require(anErr == noErr, NewPtrClear);
  1459.     
  1460.         // Initialize the appropriate fields within the status record 
  1461.         
  1462.         pStatus->statusOwner        = 'univ';
  1463.         pStatus->statResId         = gxUnivAlertStatusResourceId;
  1464.         pStatus->statResIndex     = gxUnivManualFeedIndex;
  1465.         pStatus->bufferLen         = sizeof(gxManualFeedRecord);
  1466.  
  1467.         mfeedInfo = (gxManualFeedRecord *) &pStatus->statusBuffer;
  1468.         mfeedInfo->canAutoFeed = true;
  1469.         GXGetPaperTypeName(thePaperType = GXGetFormatPaperType(pageFormat), mfeedInfo->paperTypeName);
  1470.  
  1471.         // Now display the alert to the user. Continue alerting until the user clicks OK, he cancels
  1472.         // printing, or some other fatal error happens
  1473.         do
  1474.         {
  1475.             // Issue the alert to the user
  1476.             anErr = GXAlertTheUser(pStatus);
  1477.         }
  1478.         while ( (anErr == noErr) && (pStatus->dialogResult == nil) );
  1479.         
  1480.         // Based upon the users response, we continue, cancel, or switch to auto-feed
  1481.         
  1482.         switch (pStatus->dialogResult)
  1483.         {
  1484.             case ok:                        // Assume the user loaded the paper 
  1485.                 break;
  1486.                 
  1487.             case cancel:                // User cancelled the job; make sure the error code is set
  1488.                 anErr = gxPrUserAbortErr;
  1489.                 break;
  1490.                 
  1491.             case gxAutoFeedButtonId:    // User wishes to do the remainder of the job with auto-feed. Update job to 
  1492.                                             // reflect auto-feed. 
  1493.                 
  1494.                 {
  1495.                 gxPaperFeedInfo paperFeed;
  1496.                 
  1497.                 /* Update for job */
  1498.                 paperFeed.autoFeed = true;
  1499.                 (void) AddCollectionItem(jobCollection, gxPaperFeedTag, gxPrintingTagID, sizeof(paperFeed), &paperFeed);
  1500.                 }
  1501.                 
  1502.                 /* Update as it may be reused */
  1503.                 trayFeedInfo.manualFeedThisPage = false;    /* Other trayInfo fields are still valid */
  1504.                 (void) AddCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, sizeof(trayFeedInfo), &trayFeedInfo);
  1505.                 
  1506.                 /* Can pass paper type reference as this IS device communication time */
  1507.                 anErr = Send_GXCheckStatus((Ptr) &thePaperType, sizeof(thePaperType), 0, 'univ');
  1508.                 ncheck(anErr);
  1509.                 
  1510.                 /* Update gxTrayFeedInfo.feedTrayIndex for below */
  1511.                 itemSize = sizeof(trayFeedInfo);
  1512.                 if (! anErr)
  1513.                     anErr = GetCollectionItem(jobCollection, gxTrayFeedTag, gxPrintingTagID, &itemSize, &trayFeedInfo);
  1514.                 break;
  1515.         }
  1516.         
  1517.         // Dump the status record
  1518.         DisposPtr((Ptr) pStatus);
  1519.     }
  1520.     
  1521.     require(anErr == noErr, UserAborted);
  1522.     
  1523.     // At this point we determine if there are trays attached, and if so, we need
  1524.     // to issue a command to the printer to select from the proper tray.
  1525.     
  1526.     if ( PrinterHasTrays() > 0 )    //    T => Printer does have trays attached
  1527.     {
  1528.         gxTrayIndex                whichTray;
  1529.         char                        cmndBuff[3];
  1530.         TraySettingsJobItem    oldAppTraySettings;
  1531.         
  1532.         // We first determine if we're printing from an old application or a new application because
  1533.         // the setting of which tray to use will be determined from different information. To see if
  1534.         // we are printing an old app. document, we look for the kTraySettingsItemIndex collection item.
  1535.         
  1536.         itemSize = sizeof(TraySettingsJobItem);
  1537.         if ( GetCollectionItem( GXGetJobCollection(GXGetJob()), kDrvrCreatorType, kTraySettingsItemIndex, &itemSize, &oldAppTraySettings) == noErr )
  1538.         {
  1539.             if ( (*hGlobals)->pagePrinting == 1 )    //    T => Printing the first page
  1540.             {
  1541.                 whichTray = oldAppTraySettings.firstPageFromTray - 1;        //    Must be zero based
  1542.             }
  1543.             else    //    T => Printing some other page
  1544.             {
  1545.                 whichTray = oldAppTraySettings.remainingFromTray - 1;        //    Must be zero based
  1546.             }
  1547.         }
  1548.         else    //    T => New app so get tray settings from the 'tray' collection item
  1549.         {
  1550.             // The trayFeedInfo specifies which tray to select the paper from.
  1551.             whichTray = trayFeedInfo.feedTrayIndex - 1;        // Must be zero based
  1552.         }
  1553.         
  1554.         // Compose the tray selection command
  1555.         
  1556.         cmndBuff[0] = kEscape;
  1557.         cmndBuff[1] = '@';
  1558.         cmndBuff[2] = whichTray + 0x30;        // Force to an ACSII number
  1559.         
  1560.         // Send the command to the printer
  1561.         anErr = Send_GXBufferData(cmndBuff, 3, gxNoBufferOptions);
  1562.         require(anErr == noErr, BufferData);        
  1563.     }
  1564.     
  1565.     // Update the status information to tell the user that we're sending data to the printer
  1566.     
  1567.     anErr = GXReportStatus(kDriverStatusID, kSendingPartOfPageStatIdx);
  1568.     require(anErr == noErr, ReportStatus);
  1569.  
  1570.     // Now forward the message to others in the chain
  1571.     
  1572.     anErr = Forward_GXStartSendPage(pageFormat);
  1573.     check(anErr == noErr);
  1574.     
  1575.     
  1576. /******* Cleanup *******/
  1577.  
  1578. ReportStatus:
  1579. BufferData:
  1580. UserAborted:
  1581. NewPtrClear:
  1582. FlushAllData:
  1583. GetCollectionItem:
  1584.     return(anErr);
  1585. }
  1586. /* SD_StartSendPage */
  1587.  
  1588.  
  1589. /****************************************************************************************
  1590.  
  1591.                             SD_ImagePage
  1592.                             
  1593.     function:
  1594.                 This routine is called by the Printing Manager to signal the start of imaging
  1595.                 a new page to the printer.  We take this opportunity to remember which page is
  1596.                 being printed.  This inforamtion is later used by SD_StartSendPage to control
  1597.                 the input tray selection for documents which are printed from old applications.
  1598.                 
  1599.     parameters:                
  1600.                 theFormat        format for the page being rendered
  1601.                 theShape            shape representing the page
  1602.                 pageInfo            information about the page being rendered
  1603.                 imageData        pointer to the raster image data
  1604.  
  1605.     returns:
  1606.                 OSErr
  1607.     
  1608. ****************************************************************************************/
  1609. OSErr SD_ImagePage (    gxSpoolFile                theFile, 
  1610.                             long                         pageNumber, 
  1611.                             gxFormat                    theFormat, 
  1612.                             gxRasterImageDataHdl    imageData)
  1613. {
  1614.     OSErr                    anErr;
  1615.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1616.  
  1617.     // Remember which page of the document we're currently imaging
  1618.     (*hGlobals)->pagePrinting = pageNumber;
  1619.     
  1620.     // Send the message along to others in the chain
  1621.     anErr = Forward_GXImagePage(theFile, pageNumber, theFormat, imageData);
  1622.     check(anErr == noErr);
  1623.     
  1624.     return(anErr);
  1625. }
  1626. /* SD_ImagePage */
  1627.  
  1628.  
  1629. /****************************************************************************************
  1630.  
  1631.                             SD_RenderPage
  1632.                             
  1633.     function:
  1634.                 This routine is called by the Printing Manager to signal the start of sending
  1635.                 a new page to the printer.  If it's a manual feed job, then we alert the user
  1636.                 to make sure the paper is in the printer.  Next we set the printer's left margin
  1637.                 and then we're set to begin printing the page.
  1638.                 
  1639.     parameters:                
  1640.                 theFormat        format for the page being rendered
  1641.                 theShape            shape representing the page
  1642.                 pageInfo            information about the page being rendered
  1643.                 imageData        pointer to the raster image data
  1644.  
  1645.     returns:
  1646.                 OSErr
  1647.     
  1648. ****************************************************************************************/
  1649. OSErr SD_RenderPage (gxFormat                        theFormat, 
  1650.                             gxShape                        thePage, 
  1651.                             gxPageInfoRecord            *pageInfo, 
  1652.                             gxRasterImageDataHdl     imageData)
  1653. {
  1654.     OSErr                    anErr;
  1655.     SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  1656.     gxRectangle            paperSize;
  1657.     
  1658.     // Find out how big our paper is
  1659.     GXGetFormatDimensions(theFormat, nil, &paperSize);
  1660.     
  1661.     // Determine the left margin (in pixels)
  1662.     {
  1663.         SpecGlobalsPtr            pGlobals;
  1664.         gxRasterImageDataPtr    pImageData;
  1665.  
  1666.         pImageData = *imageData;
  1667.         pGlobals = *hGlobals;
  1668.         if ( -(paperSize.left) < ff(18) )    // T => IW LQ's can't go tighter than .25 inch
  1669.             paperSize.left = -(ff(18));        
  1670.         
  1671.         pGlobals->leftMargin = FixedToInt( FixMul(-paperSize.left, FixDiv(pImageData->hImageRes, ff(72)) ) );
  1672.     }
  1673.  
  1674.     // If not text mode, image the page the normal raster way (via SD_RasterPackageBitmap).  We
  1675.     // must however set the size of the page and position the paper (with line feeds) to get to
  1676.     // the proper "top-of-form".
  1677.     
  1678.     if ( GXGetJobFormatMode(GXGetJob()) != gxTextJobFormatMode ) 
  1679.     {
  1680.         Str255            formStrLength;            // should be more than big enough for form skipping
  1681.         char                aNumber[8];
  1682.         char                len = 0;
  1683.         short                formLen;                // form length (in 144 dpi)
  1684.         short                i;
  1685.         
  1686.         // Force the current line position to be the top of form (assumes the user has positioned the 
  1687.         // paper properly by this time)
  1688.         
  1689.         formStrLength[len++] = kEscape;
  1690.         formStrLength[len++] = 'v';
  1691.  
  1692.         // Now we want to skip down the page past the top margin.  This will put us in a position to
  1693.         // output the first bands of data.
  1694.         
  1695.         formLen = FixedToInt( FixMul(-paperSize.top, ff(2)) );                    // length is set in 144 dpi
  1696.         if (formLen > 0)
  1697.         {
  1698.             // send multiples of 99 since this is the maximum line feed spacing we can have
  1699.             if (formLen >= 99)
  1700.             {
  1701.                 formStrLength[len++] = kEscape;
  1702.                 formStrLength[len++] = 'T';
  1703.                 formStrLength[len++] = '9';
  1704.                 formStrLength[len++] = '9';
  1705.                 do
  1706.                 {
  1707.                     formStrLength[len++] = kLineFeed;        // line feed
  1708.                     
  1709.                     formLen -= 99;
  1710.                 }
  1711.                 while (formLen >= 99);
  1712.             }
  1713.                 
  1714.             // Send remaining line feeds to position to the top of the printable page
  1715.             if (formLen > 0)
  1716.             {
  1717.                 formStrLength[len++] = kEscape;
  1718.                 formStrLength[len++] = 'T';
  1719.                 NumToString(formLen, aNumber);
  1720.                 if ( StrLength(aNumber) == 1 )
  1721.                 {
  1722.                     formStrLength[len++] = '0';
  1723.                     formStrLength[len++] = aNumber[1];
  1724.                 }
  1725.                 else
  1726.                 {
  1727.                     formStrLength[len++] = aNumber[1];
  1728.                     formStrLength[len++] = aNumber[2];
  1729.                 }
  1730.                 formStrLength[len++] = kLineFeed;        // line feed
  1731.             }
  1732.         }
  1733.         
  1734.         // Now we must specify the paper length based upon the paper size asociated with the format
  1735.         
  1736.         formStrLength[len++] = kEscape;
  1737.         formStrLength[len++] = 'H';
  1738.  
  1739.         formLen = FixedToInt( FixMul(paperSize.bottom - paperSize.top, ff(2)) );    // length is set in 144 dpi
  1740.         NumToString(formLen, aNumber);
  1741.         for (i = 0; i < 4-aNumber[0]; ++i)
  1742.             formStrLength[len++] = '0';
  1743.         for (i = 1; i <= aNumber[0]; ++i)
  1744.             formStrLength[len++] = aNumber[i];
  1745.  
  1746.         // Send out the line feeds and the paper size specifier
  1747.         anErr = Send_GXBufferData(&formStrLength[0], len, gxNoBufferOptions);
  1748.         require(anErr == noErr, SetFormStrLength);        
  1749.     
  1750.         // Now forward the message to others in the chain
  1751.         
  1752.         anErr = Forward_GXRenderPage(theFormat, thePage, pageInfo, imageData);
  1753.         require(anErr == noErr, Forward_GXRenderPage);
  1754.     } 
  1755.     else    //    T => Doing draft (i.e. direct mode) print job; we do all the rendering
  1756.     {
  1757.         anErr = PrintPageInDraftMode(thePage, imageData);
  1758.     }
  1759.     
  1760.     
  1761. /******* Cleanup *******/
  1762.  
  1763. SetFormStrLength:
  1764. Forward_GXRenderPage:
  1765.     return(anErr);
  1766. }
  1767. /* SD_RenderPage */
  1768.  
  1769.  
  1770. /****************************************************************************************
  1771.  
  1772.                             SD_DefaultPrinter
  1773.                             
  1774.     function:
  1775.                 This routine is called when a new printer object is being created as a
  1776.                 result of someone having called NewJob.  This message gives the driver the
  1777.                 opportunity to add any information we want to the new printer object.  In
  1778.                 this case, we add a new black and white viewDevice to the printer object 
  1779.                 which will allow the client application to format a document for this 
  1780.                 specific device at 216 dpi.  If the printer has a color ribbon attachment,
  1781.                 then we create a second view device at 216 dpi which supports eight
  1782.                 colors.
  1783.                 
  1784.     parameters:                
  1785.                 thePrinter        the newly allocated printer object
  1786.                 
  1787.     returns:
  1788.                 OSErr
  1789.                 
  1790. ****************************************************************************************/
  1791. OSErr SD_DefaultPrinter(gxPrinter thePrinter)
  1792. {
  1793.     OSErr             anErr;
  1794.     gxSetColor        theColors[8];
  1795.     gxSetColor        *pColor;
  1796.     
  1797.     // First we let others in the chain default the printer object before we do. 
  1798.  
  1799.     anErr = Forward_GXDefaultPrinter(thePrinter);
  1800.     require(anErr == noErr, Forward_GXDefaultPrinter);
  1801.     
  1802.     // Add the standard black and white view device to the printer object
  1803.     
  1804.     // First set up the color set
  1805.     pColor = &theColors[0];
  1806.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;            // white 
  1807.     pColor++;
  1808.     pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;            // black 
  1809.     
  1810.     // Now add the view device
  1811.     anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 2);
  1812.     require(anErr == noErr, MakeBWViewDevice);
  1813.     
  1814.     // Does the printer have a color ribbon installed?
  1815.     if ( PrinterHasColorRibbon() )
  1816.     {
  1817.         // Add the standard color view device to the printer object
  1818.         
  1819.         // First set up the color set
  1820.         //
  1821.         //    Color            Index        R                G                B
  1822.         //    white            0            0xFFFF        0xFFFF        0xFFFF        
  1823.         //    yellow        1            0xFFFF        0xFFFF        0x0000
  1824.         //    magenta        2            0xFFFF        0x0000        0xFFFF
  1825.         //    red            3            0xFFFF        0x0000        0x0000
  1826.         //    cyan            4            0x0000        0xFFFF        0xFFFF
  1827.         //    green            5            0x0000        0xFFFF        0x0000
  1828.         //    blue            6            0x0000        0x0000        0xFFFF
  1829.         //    black            7            0x0000        0x0000        0x0000
  1830.  
  1831.         pColor = &theColors[0];
  1832.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0xFFFF;                pColor++;        // white 
  1833.         pColor->rgb.red = pColor->rgb.green = 0xFFFF; pColor->rgb.blue = 0x0000;    pColor++;        // yellow 
  1834.         pColor->rgb.red = pColor->rgb.blue = 0xFFFF; pColor->rgb.green = 0x0000;    pColor++;        // magenta 
  1835.         pColor->rgb.red =0xFFFF;  pColor->rgb.blue = pColor->rgb.green = 0x0000;    pColor++;        // red 
  1836.         pColor->rgb.green = pColor->rgb.blue = 0xFFFF; pColor->rgb.red = 0x0000;    pColor++;        // cyan 
  1837.         pColor->rgb.red = pColor->rgb.blue = 0x0000; pColor->rgb.green = 0xFFFF;    pColor++;        // green 
  1838.         pColor->rgb.red = pColor->rgb.green = 0x0000; pColor->rgb.blue = 0xFFFF;    pColor++;        // blue 
  1839.         pColor->rgb.red = pColor->rgb.green = pColor->rgb.blue = 0x0000;                                    // black 
  1840.         
  1841.         // Now add the view device
  1842.         anErr = MakeNewPrinterViewDevice(thePrinter, theColors, 8);
  1843.         require(anErr == noErr, MakeColorViewDevice);
  1844.     }
  1845.     
  1846. /******* Clean-up *******/
  1847.  
  1848. MakeColorViewDevice:
  1849. MakeBWViewDevice:
  1850. Forward_GXDefaultPrinter:
  1851.     return(anErr);
  1852. }
  1853. /* SD_DefaultPrinter */
  1854.  
  1855. /****************************************************************************************
  1856.  
  1857.                             SD_DefaultFormat
  1858.                             
  1859.     function:
  1860.                 This routine is called when a new format is being created as a result of someone
  1861.                 having called NewFormat.  It is also called to sync up the viewDevices with the
  1862.                 collection's quality mode.
  1863.                 
  1864.     parameters:                
  1865.                 theFormat        the format being defaulted
  1866.                 
  1867.     returns:
  1868.                 OSErr
  1869.                 
  1870. ****************************************************************************************/
  1871. OSErr SD_DefaultFormat(gxFormat theFormat)
  1872. {
  1873.     OSErr                anErr;
  1874.     Handle             jobQualitySettingsHdl;    
  1875.     
  1876.     anErr = Forward_GXDefaultFormat(theFormat);
  1877.     
  1878.     // now, if the application has set up a special formatting mode, we need to update
  1879.     // the quality mode collection item (and any private ones we use)
  1880.     if (anErr == noErr)
  1881.         {
  1882.         gxPoint                    dpiPoint = {ff(72), ff(72)};
  1883.         gxMapping                vdMapping;
  1884.         gxViewDevice            selectedDevice = GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 0);
  1885.         
  1886.         if (selectedDevice != GXGetPrinterViewDevice(GXGetJobPrinter(GXGetFormatJob(theFormat)), 1) )
  1887.             {
  1888.             GXGetViewDeviceMapping(selectedDevice, &vdMapping);
  1889.             MapPoints(&vdMapping, 1, &dpiPoint);
  1890.             
  1891.             {
  1892.             gxQualityInfo        *qualitySettings;
  1893.             Collection            jobCollection = GXGetJobCollection(GXGetJob());
  1894.     
  1895.             jobQualitySettingsHdl = NewHandle(0);
  1896.             anErr = MemError();
  1897.             nrequire(anErr, FailedNewHandle);
  1898.  
  1899.             anErr = GetCollectionItemHdl (     jobCollection,
  1900.                                                         gxQualityTag,
  1901.                                                          gxPrintingTagID,
  1902.                                                        jobQualitySettingsHdl );
  1903.  
  1904.             if (anErr == collectionItemNotFoundErr) 
  1905.                 {
  1906.                 Str255            bestString, roughString;
  1907.                 Size                count1, count2;
  1908.                 Ptr                p;
  1909.         
  1910.                 GetIndString( bestString, kQualityID, kBestString);
  1911.                 GetIndString( roughString, kQualityID, kRoughString);
  1912.  
  1913.                 SetHandleSize(jobQualitySettingsHdl,(sizeof(gxQualityInfo) + bestString[0] + roughString[0] + 2 ));
  1914.                 anErr = MemError();
  1915.                 nrequire( anErr, FailedSetHandleSize );
  1916.                         
  1917.                 qualitySettings = *((gxQualityInfo **) jobQualitySettingsHdl);
  1918.                 
  1919.                 qualitySettings->disableQuality = false;
  1920.                 qualitySettings->defaultQuality = 1;
  1921.                 qualitySettings->currentQuality = 1;
  1922.                 qualitySettings->qualityCount = 2;
  1923.         
  1924.                 count1 = bestString[0]+1;
  1925.                 p = qualitySettings->qualityNames;
  1926.                 BlockMove( bestString, p, count1 );
  1927.         
  1928.                 count2 = roughString[0]+1;
  1929.                 p += count1;
  1930.                 BlockMove( roughString, p, count2 );
  1931.         
  1932.                 }
  1933.             else
  1934.                 qualitySettings = *((gxQualityInfo **) jobQualitySettingsHdl);
  1935.  
  1936.             qualitySettings->currentQuality = 
  1937.                 (dpiPoint.y > ff(200)) ? (qualitySettings->qualityCount-1) : 0;
  1938.  
  1939.             anErr = AddCollectionItemHdl (     jobCollection,
  1940.                                                         gxQualityTag,
  1941.                                                         gxPrintingTagID,
  1942.                                                         jobQualitySettingsHdl );
  1943.                                                  
  1944.             if (anErr == noErr)
  1945.                 (void) SetCollectionItemInfo(jobCollection, gxQualityTag, gxPrintingTagID, 0x0000FFFF, gxVolatileOutputDriverCategory);
  1946.                 
  1947.             DisposHandle(jobQualitySettingsHdl);
  1948.             }
  1949.             
  1950.             }
  1951.  
  1952.         }
  1953.         
  1954. FailedNewHandle:        
  1955.     return(anErr);
  1956.  
  1957. FailedSetHandleSize:
  1958.     DisposHandle(jobQualitySettingsHdl);
  1959.     return(anErr);
  1960.     
  1961. } 
  1962. /* SD_DefaultFormat */
  1963.  
  1964. /****************************************************************************************
  1965.  
  1966.                             SD_DefaultJob
  1967.                             
  1968.     function:
  1969.                 This routine is called when a new job is being created as a result of someone
  1970.                 having called NewJob.  The driver takes this opportunity to add a default
  1971.                 head motion collection item to the job.
  1972.                 
  1973.     parameters:                
  1974.                 theJob        the job being defaulted
  1975.                 
  1976.     returns:
  1977.                 OSErr
  1978.                 
  1979. ****************************************************************************************/
  1980. OSErr SD_DefaultJob()
  1981. {
  1982.     OSErr        anErr;
  1983.     gxJob     theJob = GXGetJob();
  1984.     
  1985.     // First forward the default job message along
  1986.     anErr = Forward_GXDefaultJob();
  1987.     require(anErr == noErr, Forward_GXDefaultJob);
  1988.     
  1989.     // Add the default collection item which specifies the desired head motion.
  1990.     {
  1991.         HeadMotionJobItem        theMotion;
  1992.         
  1993.         theMotion.direction = doUnidirectional;
  1994.         
  1995.         anErr = AddCollectionItem(    GXGetJobCollection(theJob), 
  1996.                                             kDrvrCreatorType, 
  1997.                                             kHeadMotionItemIndex, 
  1998.                                             sizeof(HeadMotionJobItem),
  1999.                                             &theMotion);
  2000.         check(anErr == noErr);
  2001.     }
  2002.  
  2003.  
  2004. /******* Clean-up *******/
  2005.  
  2006. Forward_GXDefaultJob:
  2007.     return(anErr);
  2008. }
  2009. /* SD_DefaultJob */
  2010.  
  2011.  
  2012. /****************************************************************************************
  2013.  
  2014.                             SD_SetupImageData
  2015.                             
  2016.     function:
  2017.                 This routine is called when the Printing Manager wants us to initialize any
  2018.                 constant data that's used to image the entire job.  This driver takes this
  2019.                 opportunity to massage the raster image data 
  2020.                 
  2021.     parameters:                
  2022.                 hImageData        Handle to the raster imaging data
  2023.     returns:
  2024.                 OSErr
  2025.     
  2026. ****************************************************************************************/
  2027. OSErr SD_SetupImageData(gxRasterImageDataHdl hImageData)
  2028. {
  2029.     OSErr                        anErr;
  2030.     Boolean                     isJobNotFinalQuality;
  2031.     Boolean                    isTextJobFormatMode;
  2032.     gxRasterImageDataPtr    pImageData;
  2033.     HeadMotionJobItem        theMotion;
  2034.     long                        headMotionSize;
  2035.     gxJob                        theJob = GXGetJob();
  2036.  
  2037.     // Let others in the message chain do their SetupImageData function 
  2038.     anErr = Forward_GXSetupImageData(hImageData);
  2039.     require(anErr == noErr, Forward_GXSetupImageData);
  2040.     
  2041.     // Determine if we're to do "final" quality
  2042.     isJobNotFinalQuality = !JobIsBestQuality();
  2043.     
  2044.     // Fetch the head motion job collection item to determine the head motion we should be using
  2045.  
  2046.     headMotionSize = sizeof(HeadMotionJobItem);
  2047.     anErr = GetCollectionItem (GXGetJobCollection(theJob),
  2048.                                         kDrvrCreatorType,
  2049.                                         kHeadMotionItemIndex,
  2050.                                         &headMotionSize,
  2051.                                         &theMotion);
  2052.     check(anErr == noErr);
  2053.     
  2054.     if (anErr != noErr)    //    T => Default to unidirectional printing => better quality
  2055.     {
  2056.         theMotion.direction = doUnidirectional;
  2057.         anErr = noErr;
  2058.     }
  2059.  
  2060.     // Determine if we are to perform draft mode printing
  2061.     isTextJobFormatMode = ( GXGetJobFormatMode(theJob) == gxTextJobFormatMode );
  2062.     
  2063.     // If the job is not final quality or using textJobFormatMode, downgrade the imaging data to lower quality
  2064.     if (isJobNotFinalQuality || isTextJobFormatMode)
  2065.     {
  2066.         pImageData = *hImageData;
  2067.                 
  2068.         // Image at 72 dpi
  2069.         pImageData->hImageRes = ff(72);
  2070.         pImageData->vImageRes = ff(72);
  2071.         
  2072.         // If we're in draft mode, we need to load the draft table to know how to print all possible characters
  2073.         if (isTextJobFormatMode)
  2074.         {
  2075.             Handle                draftTable;
  2076.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2077.         
  2078.             anErr = Send_GXFetchTaggedDriverData('idft', gxPrintingDriverBaseID, &draftTable);
  2079.             require(anErr == noErr, FailedToLoadDraftTable);
  2080.             
  2081.             // Save the draft table handle in our globals
  2082.             (*hGlobals)->draftTable = draftTable;
  2083.         }
  2084.         else    //    T => We need to setup better low resolution halftones
  2085.         {
  2086.             short    plane;
  2087.             
  2088.             // Use halftones that will look better at 72 dpi resolution than our default values.
  2089.             
  2090.             // Use the same angle and frequency for all planes, because orderDitherDot
  2091.             // won't moire on us
  2092.             for (plane = 0; plane < 4; ++plane)
  2093.             {
  2094.                 pImageData->theSetup.planeSetup[plane].planeHalftone.angle = ff(0);
  2095.                 pImageData->theSetup.planeSetup[plane].planeHalftone.frequency = ff(9);
  2096.                 pImageData->theSetup.planeSetup[plane].planeHalftone.method = gxDispersedDot;
  2097.             }
  2098.         }
  2099.         
  2100.         // Determine the StartSendPage command string to use depending upon whether the user choose birdirectional or
  2101.         // unidirectional motion.
  2102.         
  2103.         if (isJobNotFinalQuality)
  2104.         {
  2105.             // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2106.             // or unidirectional string)
  2107.             
  2108.             if ( theMotion.direction == doUnidirectional )
  2109.                 pImageData->packageControls.startPageStringID = kLowResUniDirID;
  2110.             else
  2111.                 pImageData->packageControls.startPageStringID = kLowResBiDirID;
  2112.         }
  2113.         
  2114.         // Update the packaging data to reflect the lower resolution
  2115.         pImageData->packagingInfo.headHeight         = 8;        // 8 pins (instead of 24)
  2116.         pImageData->packagingInfo.numberPasses     = 1;        // in 1 head pass
  2117.         pImageData->packagingInfo.passOffset         = 0;        // with no space between passes
  2118.     }
  2119.     else    //    T => Final quality job
  2120.     {
  2121.         pImageData = *hImageData;
  2122.                 
  2123.         // Tell the Printing Manager which "start send page" string to send to the device (the bidirectional
  2124.         // or unidirectional string)
  2125.         
  2126.         if ( theMotion.direction == doUnidirectional )
  2127.             pImageData->packageControls.startPageStringID = kHighResUniDirID;
  2128.         else
  2129.             pImageData->packageControls.startPageStringID = kHighResBiDirID;
  2130.  
  2131.         // image at 216 dpi
  2132.         pImageData->hImageRes = ff(216);
  2133.         pImageData->vImageRes = ff(216);
  2134.     }
  2135.     
  2136.     // If the printer doesn't have a color ribbon, set up for black and white printing
  2137.     if ( !PrinterHasColorRibbon() )
  2138.     {
  2139.         pImageData = *hImageData;
  2140.  
  2141.         // one plane, no color flags, move the halftone info up into correct position
  2142.         pImageData->theSetup.planes = 1;
  2143.         pImageData->packagingInfo.colorPasses = 1;
  2144.         pImageData->packagingInfo.packageOptions = 0;
  2145.         pImageData->theSetup.planeSetup[0] = pImageData->theSetup.planeSetup[3];
  2146.         pImageData->theSetup.planeSetup[0].planeHalftone.tinting = gxLuminanceTint;
  2147.         pImageData->theSetup.planeSetup[0].planeHalftone.tintSpace = gxRGBSpace;
  2148.     }
  2149.  
  2150.  
  2151. /******* Clean-up *******/
  2152.  
  2153. FailedToLoadDraftTable:
  2154. Forward_GXSetupImageData:
  2155.     return(anErr);
  2156. }
  2157. /* SD_SetupImageData */
  2158.  
  2159.  
  2160. /****************************************************************************************
  2161.  
  2162.                             SD_FetchTaggedData
  2163.                             
  2164.     function:
  2165.                 This routine is called by the Printing Manager when a resource is fetched
  2166.                 from some resource file.  This driver overrides this message to determine
  2167.                 when someone is fetching the 'cust' resource.  If this resource
  2168.                 is being fetched, and the job we're processing is not best quality, then
  2169.                 we lower the resolution in the 'cust' resource handle returned to be 72 dpi.
  2170.                 This ensures the translation from QuickDraw to QuickDraw GX is done at the
  2171.                 proper resolution.
  2172.                 
  2173.     parameters:    
  2174.                 rsrcType            type of the resource being retrieved
  2175.                 rsrcID            resource ID of the resource being retrieved
  2176.                 theRsrc            handle to the resource retrieved
  2177.                 owner                indicates who is issuing the request; only look at owners == 'drvr'
  2178.                 
  2179.     returns:
  2180.                 OSErr
  2181.  
  2182. ****************************************************************************************/
  2183. OSErr SD_FetchTaggedData(ResType rsrcType, short rsrcID, Handle *theRsrc, OSType owner)
  2184. {
  2185.     OSErr        anErr;
  2186.     
  2187.     if (owner == 'drvr')                                                    //    T => Fetching a driver resource
  2188.     {
  2189.         if (    (rsrcType == gxTrayCountDataType)    &&                    //    T => type is trayCountData
  2190.                 (rsrcID == gxTrayCountDataID)                            //    T => ID is trayCountData
  2191.             )
  2192.         {
  2193.             // Remap as required
  2194.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFeederRsrcID : kDefaultTrayRsrcID);
  2195.         }
  2196.         else if (    (rsrcType == gxTrayNameDataType)    &&            //    T => type is trayName
  2197.                         (rsrcID == kDefaultSheetFdrTray1NameID)    //    T => ID is trayData
  2198.             )
  2199.         {
  2200.             // Remap as required
  2201.             rsrcID = ((PrinterHasTrays() > 0) ? kDefaultSheetFdrTray1NameID : kDefaultTrayNameID);
  2202.         }
  2203.     }
  2204.     
  2205.     // First fetch the actual resource
  2206.     anErr = Forward_GXFetchTaggedData(rsrcType, rsrcID, theRsrc, owner);
  2207.     require(anErr == noErr, FetchTaggedData);
  2208.     
  2209.     if (    (owner == 'drvr')                &&        //    T => Fetching a driver resource
  2210.             (rsrcType == gxCustType)    &&        //    T => type is 'cust'
  2211.             (rsrcID == gxCustID)            &&        //    T => ID is -8192
  2212.             !JobIsBestQuality()                    //    T => Doing rough output
  2213.         )
  2214.     {
  2215.         gxCustomizationHdl    custData;
  2216.         
  2217.         // Change the 'cust' resolution to specify low res translation from QuickDraw to QuickDraw GX
  2218.         (*custData)->horizontalResolution = 72;
  2219.         (*custData)->verticalResolution = 72;
  2220.     }
  2221.  
  2222.  
  2223. /******* Clean-up *******/
  2224.  
  2225. FetchTaggedData:
  2226.     return(anErr);
  2227. }
  2228. /* SD_FetchTaggedData */
  2229.  
  2230.  
  2231. /****************************************************************************************
  2232.  
  2233.                             SD_DefaultDesktopPrinter
  2234.                             
  2235.     function:
  2236.                 This routine is called by the Printing Manager when a new desktop printer is
  2237.                 created.  We take this opportunity to open a connection to the LQ printer to
  2238.                 see how it's configured.  Specifically, we determine if there are trays
  2239.                 attached and if there is a color ribbon installed.  Based upon the device query,
  2240.                 we update the desktop printer file.
  2241.                 
  2242.     parameters:    
  2243.                 printerName        Name of the printer being created
  2244.                 
  2245.     returns:
  2246.                 OSErr
  2247.  
  2248. ****************************************************************************************/
  2249. OSErr SD_DefaultDesktopPrinter(Str31 printerName)
  2250. {
  2251.     OSErr        anErr;
  2252.     
  2253.     // First let the Printing Manager create the desktop printer
  2254.     anErr = Forward_GXDefaultDesktopPrinter(printerName);
  2255.     require(anErr == noErr, DefaultDesktopPrinter);
  2256.     
  2257.     // Optional step (now removed): during creation of the printer we could open a connection
  2258.     // to get the current configuration.  However, this has the disadvantage of making the user
  2259.     // wait until the printer is available.  The user can force a configuration update by printing
  2260.     // any document to the printer (even a blank one)
  2261.     
  2262.     // Now we attempt to open a connection to the device (it will update the config. file)
  2263. //    anErr = Send_GXOpenConnection();
  2264. //    require(anErr == noErr, OpenConnection);
  2265.     
  2266.     // A side effect of opening the connection will be that we will have already updated
  2267.     // the configuration information (in the file) that specifies whether a color ribbon
  2268.     // is installed and the number of sheet feeder trays attached (if any). ## The only additional
  2269.     // thing we'd want to do here is to update the number of trays specified in the desktop
  2270.     // printer file to be the actual number of trays attached to the device.  Currently, the 
  2271.     // system assumes the number of trays attached is equivalent to the number of default
  2272.     // trays specified in our driver resources.  Though we can query the printer for the 
  2273.     // exact number of trays, we cannot update the info. in the config. file that specifies
  2274.     // the exact number of trays.  We need a RemoveTrayInfo routine.
  2275.     
  2276.     // Now we just close down the connection
  2277. //    anErr = Send_GXCloseConnection();
  2278. //    check(anErr == noErr);
  2279.  
  2280.     
  2281. /******* Clean-up *******/
  2282.  
  2283. OpenConnection:
  2284. DefaultDesktopPrinter:
  2285.     return(anErr);
  2286. }
  2287. /* SD_DefaultDesktopPrinter */
  2288.  
  2289.  
  2290. /****************************************************************************************
  2291.  
  2292.                             SD_GetDTPMenuList
  2293.                             
  2294.     function:
  2295.                 NOOP.
  2296.                 
  2297.     parameters:    
  2298.                 hMenu            Handle to the menu that's being built
  2299.                 
  2300.     returns:
  2301.                 OSErr
  2302.  
  2303. ****************************************************************************************/
  2304. OSErr SD_GetDTPMenuList(MenuHandle hMenu)
  2305. {
  2306.     return(Forward_GXGetDTPMenuList(hMenu));
  2307. }
  2308. /* SD_GetDTPMenuList */
  2309.  
  2310.  
  2311. /****************************************************************************************
  2312.  
  2313.                             SD_DTPMenuSelect
  2314.                             
  2315.     function:
  2316.                 This routine is called by the Printing Manager when a menu item in the Finder's
  2317.                 Printer menu is selected.  This routine determines if the menu item selected
  2318.                 is the "Input Tray…" item. If it's, then display the dialog which lets the user
  2319.                 specify the paper in the LQ's sheet feeder if we know there are some trays
  2320.                 attached to the printer.  Otherwise, we just pass the item on to others in the chain.
  2321.                 
  2322.     parameters:    
  2323.                 itemNum        Menu item number that was selected
  2324.                 
  2325.     returns:
  2326.                 OSErr
  2327.  
  2328. ****************************************************************************************/
  2329. OSErr SD_DTPMenuSelect(short itemNum)
  2330. {
  2331.     OSErr        anErr;
  2332.     
  2333.     if ((itemNum == gxInputTraysMenuItem) && (PrinterHasTrays() > 0))    //    T => User wants to configure the input trays
  2334.     {
  2335.         anErr = DoSheetfeederDialog();
  2336.         
  2337.     }
  2338.     else    //    T => We didn't process the item
  2339.     {
  2340.         // Pass the message on to others in the chain
  2341.         anErr = Forward_GXDTPMenuSelect(itemNum);
  2342.     }
  2343.     
  2344.     check(anErr == noErr);
  2345.  
  2346.     return(anErr);
  2347. }
  2348. /* SD_DTPMenuSelect */
  2349.  
  2350.  
  2351. /****************************************************************************************
  2352.  
  2353.                             SD_RasterPackageBitmap
  2354.                             
  2355.     function:
  2356.                 This routine is called by the Printing Manager when it has completed rendering
  2357.                 a single portion of a raster page and the driver should now package the data
  2358.                 and output it to the device.  This routine is called to package one complete band.
  2359.                 
  2360.                 It routine does the following:
  2361.                     
  2362.                 1)    Starts filling the buffer from buffer + bufferPos.  Remember
  2363.                     that this pointer may not be word aligned - so be careful
  2364.                     assigning things into it.
  2365.                     
  2366.                 2)    Puts a "fake" set of set margins commands at
  2367.                     the begining of the data.  Since most of the time we don't
  2368.                     know the margins, we save away the value of the bufferPos,
  2369.                     and backpatch it after we have finished with the bitmap.
  2370.                     
  2371.                 3)    Adds in the rotated data for your printer.  The data to stuff starts
  2372.                     at location pPackage->startRaster * pPackage->bitmapToPackage->rowBytes (startY)
  2373.                     in the pPackage->bitmapToPackage bitmap.  Stuffs the bits from here until
  2374.                     we reach startY + <the band size>, which is the size of our single
  2375.                     band in this resolution mode.  Increment our number by 
  2376.                     <your pass offset> + 1, which is the number of microspaces
  2377.                     we will send between head passes to form this band.   Take care
  2378.                     that we don't step off of the end of the bitmap in this operation,
  2379.                     since we may be called with startY at the end of the offscreen if the first part
  2380.                     of the band is white.
  2381.                     
  2382.                     colorBand contains the color band which we should be stuffing, from
  2383.                     1 to the number of color passes our printer needs (4).
  2384.                     Packs in the correct color band.  The packager will call us once
  2385.                     for each color band, and correctly handle line feeds and backward
  2386.                     line feeds to do the correct thing.  If your printer takes full
  2387.                     RGB or CYMK data, define your number of colors to be
  2388.                     1 and pack the full RGB or CYMK data with the one call.
  2389.                     
  2390.                     If you request kSendAllColors in your raster pack resource, then this
  2391.                     message will always be called for all color passes, even those that
  2392.                     do not have data on them.  For some printers, this is useful.  For the
  2393.                     case of the ImageWriter, this option is not specified, so this message
  2394.                     will only be sent for colors that actually have dirty bits within them.
  2395.                     
  2396.                 4)    Backpatches SetMargins from the saved value in step 2) now that we
  2397.                     know the margins.
  2398.                     
  2399.                 5)    Increments bufferPos by the number of bytes we have
  2400.                     added to the buffer.  Be sure to take into account the Set Margins
  2401.                     command.
  2402.  
  2403.     parameters:        
  2404.                 whatToPackage        info. about the bitmap whose data is to be sent to the printer
  2405.                 buffer                buffer in which to place the packaged data
  2406.                 bufferPos            position within buffer of where to place the packaged data
  2407.                 imageData            handle to the raster image data info.
  2408.                 
  2409.     returns:
  2410.                 OSErr
  2411.  
  2412. ****************************************************************************************/
  2413. OSErr SD_RasterPackageBitmap(    gxRasterPackageBitmapRec    *whatToPackage, 
  2414.                                         Ptr                                 buffer,
  2415.                                         unsigned long                     *bufferPos, 
  2416.                                         gxRasterImageDataHdl            imageData)
  2417. {
  2418.     OSErr                    anErr = noErr;
  2419.     ScanLinePtr            pTheScanLine;            // Pointer to the start of scan line data
  2420.     unsigned short        firstDirty;                // First dirty pixel
  2421.     Boolean                bandIsDirty;            // Is this band dirty?
  2422.     unsigned short        whichCol;                // Index into the scan line data of where to place the next data bytes
  2423.     unsigned short        x;                            
  2424.     unsigned long        tempColumn;                // Placeholder for the column of data we're currently assembling
  2425.                                                         //    for 72 dpi:     only high order byte is used
  2426.                                                         //    for 216 dpi:    highest order three bytes are used
  2427.     Ptr                    basePtr;                    // Pointer to current X byte
  2428.     unsigned char        outputMask;                // Mask of bit to set in rotated image
  2429.     unsigned char        inputMask;                // Mask of bit to look at in X
  2430.     unsigned short        yPointerOffset;        // Increment pointer by this to get to next scanline
  2431.     unsigned short        endY;                        //    Last scan line to examine (top-to-bottom)
  2432.     unsigned short        endX;                        //    Last pixel column to examine (left-to-right)
  2433.     unsigned short        incrY;                    //    Number of scan lines to increment by when advancing to the next scan line
  2434.     short                    bytesPerBand;            //    Number of bytes in a single band (1 for 72 dpi, 3 for 216 dpi)
  2435.             
  2436.  
  2437.     // Determine the number of bytes that are in a single band 
  2438.     if ( (*imageData)->hImageRes == ff(72) )    //    T => Low resolution output
  2439.         bytesPerBand = 1;
  2440.     else
  2441.         bytesPerBand = 3;
  2442.     
  2443.     //    Overlay a scan line structure on the buffer we're filling in 
  2444.     pTheScanLine = (ScanLinePtr) (buffer + *bufferPos);
  2445.     
  2446.     // Set color mode for this scan line, if needed 
  2447.     
  2448.     pTheScanLine->cColorEscape = kEscape;
  2449.     pTheScanLine->cSetColorCommand = kSetColorCommand;
  2450.     
  2451.     if ( (*imageData)->packagingInfo.colorPasses == 4 )    //    T => Doing four pass color output
  2452.     {
  2453.         switch (whatToPackage->colorBand)    //    Determine which color to select
  2454.         {
  2455.             case 1: // yellow
  2456.                 pTheScanLine->cColor    = '1';
  2457.                 break;
  2458.                 
  2459.             case 2: // magenta
  2460.                 pTheScanLine->cColor    = '2';
  2461.                 break;
  2462.  
  2463.             case 3: // cyan
  2464.                 pTheScanLine->cColor    = '3';
  2465.                 break;
  2466.                 
  2467.             case 4: // black
  2468.                 pTheScanLine->cColor    = '0';
  2469.                 break;
  2470.         }
  2471.     }
  2472.     else    //    T => Just doing black and white printing; select the color black
  2473.         pTheScanLine->cColor = '0';
  2474.  
  2475.     // We start out with no dirty bits
  2476.     firstDirty = 0;
  2477.     bandIsDirty = false;
  2478.     
  2479.     // Set our array index to zero
  2480.     whichCol = 0;
  2481.     
  2482.     // Get the byte pointer for the start of this color band
  2483.     basePtr = whatToPackage->bitmapToPackage->image;
  2484.     
  2485.     // Get the byte pointer for the start of the first scan line
  2486.     basePtr += whatToPackage->startRaster * whatToPackage->bitmapToPackage->rowBytes;
  2487.             
  2488.     // Save away loop invariants
  2489.     
  2490.     endY = whatToPackage->startRaster + (*imageData)->packagingInfo.headHeight;    // Ending Y scan line
  2491.     incrY = (*imageData)->packagingInfo.passOffset + 1;                                    // Number of scanlines to increment by
  2492.     endX = whatToPackage->dirtyRect.right;                                                        // Ending X pos
  2493.     yPointerOffset = incrY * whatToPackage->bitmapToPackage->rowBytes;                // amount to add to the input pointer to move to the next scanline
  2494.  
  2495.     // If the ending position is too large for the bitmap we have been given,
  2496.     //truncate it, so that we don't print garbage
  2497.  
  2498.     if (endY > whatToPackage->bitmapToPackage->height)
  2499.          endY = whatToPackage->bitmapToPackage->height;
  2500.     
  2501.     // Start with the first bit in the byte sub-band
  2502.     inputMask = 0x80;
  2503.  
  2504.     // For the entire width of the scan line, move a rolling mask along in the
  2505.     // X direction, rotating up 8 or 24 bits of Y data per column.
  2506.     
  2507.     for (x = 0; x < endX; x++)
  2508.     {        
  2509.         Ptr    thePtr;
  2510.  
  2511.         // The bits in this column are clear to begin with
  2512.         tempColumn = 0;
  2513.         
  2514.         // Which byte(s) to look at in the input buffer
  2515.         thePtr = basePtr;
  2516.         
  2517.         // For the number of bytes in a single band, scan through each single  
  2518.         // byte sub-band, setting each of the 8 bits = the bit in that scan line
  2519.         {
  2520.             short                    bitsPerByte;
  2521.             short                    byteSubBand = bytesPerBand;
  2522.             unsigned char        *currByte = (unsigned char *) &tempColumn;
  2523.             short                    currYPos;
  2524.             
  2525.             currYPos = whatToPackage->startRaster;
  2526.             
  2527.             do
  2528.             {
  2529.                 // Where to place the bit in the output. The LQ takes the bit pattern upside down.
  2530.                 outputMask = 0x01;
  2531.         
  2532.                 bitsPerByte = 8;
  2533.                 while ( (bitsPerByte > 0) && (currYPos < endY) )
  2534.                 {
  2535.                     // If we have a bit turned on in the input, rotate it into the output
  2536.                     if ( ((*thePtr) & inputMask) != 0 )
  2537.                         *currByte |= outputMask;
  2538.         
  2539.                     // move onto next position in the output data                
  2540.                     outputMask <<= 1;
  2541.                     
  2542.                     // move onto the next scan line in the input data
  2543.                     thePtr += yPointerOffset;
  2544.                     
  2545.                     // Indicate we processed one of the bits
  2546.                     bitsPerByte--;
  2547.                     
  2548.                     // Keep track of our Y position as we move down the column
  2549.                     currYPos += incrY;
  2550.                 }
  2551.                 
  2552.                 if (currYPos >= endY)    //    T => We're done with this column
  2553.                     break;
  2554.                     
  2555.                 // Indicate we processed one of the byte rows in the band
  2556.                 byteSubBand--;
  2557.                 
  2558.                 // Bump to the next byte to fill in tempColumn
  2559.                 currByte++;
  2560.             }
  2561.             while (byteSubBand > 0);
  2562.         }
  2563.             
  2564.         // Save the column info (a max. of three bytes). Note: we'll only advance whichCol based upon the number of bytes per band
  2565.         BlockMove((Ptr) &tempColumn, (Ptr) &(pTheScanLine->iTheData[whichCol]), 3);
  2566.         
  2567.         // If we have some form of data, then mark that this band is dirty
  2568.         if (tempColumn != 0)
  2569.         {
  2570.             if (!bandIsDirty)    //    T => Not already dirty; remember the first dirty pixel
  2571.             {
  2572.                 /* These are the first dirty pixels we have seen so far */
  2573.                 bandIsDirty = true;
  2574.                 firstDirty = x;
  2575.             }
  2576.         }
  2577.             
  2578.         // If we have some dirty bits, adjust the whichCol variable based upon the number of bytes in a band
  2579.         if (bandIsDirty)
  2580.         {
  2581.             // Move on to the next column or set of columns
  2582.             whichCol += bytesPerBand;
  2583.         }
  2584.  
  2585.         // Position for the next bit in the input byte currently referenced by basePtr
  2586.         inputMask >>= 1;
  2587.         
  2588.         if (inputMask == 0)    //    T => Need to reset the input mask and advance the pointer
  2589.         {
  2590.             // Get the next byte
  2591.             basePtr++;
  2592.             
  2593.             // Reset the bit mask to the first bit
  2594.             inputMask = 0x80;
  2595.         }
  2596.     } // end of loop for width of bitmap
  2597.  
  2598.     // If we have a dirty band, fill in the left margin setting and add a carriage return to the end
  2599.     if (bandIsDirty)
  2600.     {            
  2601.         // Set the left margin to be the first dirty pixel in the scan line
  2602.         {
  2603.             SpecGlobalsHdl     hGlobals = GetMessageHandlerInstanceContext();
  2604.             
  2605.             check(hGlobals);
  2606.             
  2607.             // Stuff in the set margin command
  2608.             
  2609.             pTheScanLine->cMarginsEscape = kEscape;
  2610.             pTheScanLine->cMarginsCommand = (bytesPerBand == 1) ? kLowResMarginsCommand : kHighResMarginsCommand;
  2611.             
  2612.             // Convert left margin into ASCII and place it at the start of the scan line
  2613.             Long2Dec((*hGlobals)->leftMargin + firstDirty, (Ptr) (pTheScanLine->cIndentDistance));
  2614.         }
  2615.         
  2616.         // Now fill in the last escape sequence command depending upon if we're doing low-res or high-res graphics
  2617.         
  2618.         pTheScanLine->cEscape = kEscape;
  2619.         pTheScanLine->cCommand = (bytesPerBand == 1)    ? kLowResGraphicsCommand : kHighResGraphicsCommand;
  2620.  
  2621.         // If we're doing high-res, then whichCol must be divided by three to compensate for the 3-byte buffer entries
  2622.         {
  2623.             short        adjustedWhichCol = whichCol;
  2624.             
  2625.             if (bytesPerBand == 3)
  2626.                 adjustedWhichCol /= 3;
  2627.                 
  2628.             Long2Dec(adjustedWhichCol, (Ptr) (pTheScanLine->cLineStrLength));
  2629.         }
  2630.         
  2631.         
  2632.         //    Increment the count of the number of bytes that have been added to the buffer
  2633.         *bufferPos += kScanLineHdrSize + whichCol;
  2634.  
  2635.         // Lastly, put a <cr> at the end of the line
  2636.         *(buffer + *bufferPos) = '\n';
  2637.         *bufferPos += 1;
  2638.     }
  2639.         
  2640.     return(anErr);
  2641. }
  2642. /* SD_RasterPackageBitmap */
  2643.  
  2644.  
  2645. /****************************************************************************************
  2646.  
  2647.                             SD_RasterLineFeed
  2648.                             
  2649.     function:
  2650.                 This routine is called by the Printing Manager to send the appropriate line
  2651.                 feed commands to the printer i norder to skip up or down the page the 
  2652.                 equivalent of lineFeedSize pixels.
  2653.                 
  2654.     parameters:    
  2655.                 lineFeedSize    number of pixels to line feed by
  2656.                 buffer            buffer in which to place the linefeed packaging commands
  2657.                 bufferPos        offset within buffer at which to place the linefeed commands
  2658.                 imageData        handle to the raster image data
  2659.                 
  2660.     returns:
  2661.                 OSErr
  2662.  
  2663. ****************************************************************************************/
  2664. OSErr SD_RasterLineFeed(short                     *lineFeedSize, 
  2665.                                 Ptr                         buffer, 
  2666.                                 unsigned long            *bufferPos, 
  2667.                                 gxRasterImageDataHdl    imageData)
  2668. {
  2669.     OSErr        anErr = noErr;
  2670.     
  2671.     // If there is no need for any line feeds, then just return now
  2672.     if (*lineFeedSize == 0)
  2673.         return(anErr);
  2674.         
  2675.     // If we are in low res mode, we double the line feed size, as all ImageWriter LQ 
  2676.     // line feed commands are expressed at 144 dpi.
  2677.     if ( (*imageData)->vImageRes == ff(72) )
  2678.     {
  2679.         *lineFeedSize <<= 1;
  2680.         
  2681.         // do the line feed in the default way
  2682.         anErr = Forward_GXRasterLineFeed(lineFeedSize, buffer, bufferPos, imageData);
  2683.  
  2684.         *lineFeedSize >>= 1;
  2685.     }
  2686.     else    //    T => In high res. mode; must determine the number of 1/144 inch and 1/216 inch line feeds needed
  2687.     {
  2688.         Ptr        nextByte;    
  2689.         fixed        lineFeedInInches;
  2690.         fixed        oneOver144;
  2691.         fixed        remainder;
  2692.         short        num216FractLineFeeds;
  2693.         fixed        num144FractLineFeeds;
  2694.         Str31        aNumber;
  2695.                         
  2696.         // Determine the location at which we'll begin inserting commands
  2697.         nextByte = buffer + *bufferPos;
  2698.         
  2699.         // Is line feed movement going to be backward?
  2700.         if ( *lineFeedSize < 0 )
  2701.         {
  2702.             *lineFeedSize = -(*lineFeedSize);    // Force positive
  2703.             
  2704.             // Add the backward direction command to the buffer
  2705.             *nextByte++ = kEscape;
  2706.             *nextByte++ = 'r';
  2707.         }
  2708.         else    //    T => Paper motion is forward
  2709.         {
  2710.             // Add the forward direction command to the buffer
  2711.             *nextByte++ = kEscape;
  2712.             *nextByte++ = 'f';
  2713.         }
  2714.         
  2715.         // Update the count of the number of bytes added to the buffer
  2716.         *bufferPos += 2;
  2717.         
  2718.         // Determine the number of inches we need to skip with the line feed command
  2719.         lineFeedInInches = FixDiv( IntToFixed(*lineFeedSize), ff(216) );
  2720.         
  2721.         // Determine the integral number of 1/144 inch increments the line feed space comprises
  2722.         
  2723.         oneOver144 = FixDiv(ff(1), ff(144));
  2724.         num144FractLineFeeds = FixDiv( lineFeedInInches, oneOver144 );
  2725.         
  2726.         // Determine the remaining 1/216 inch line feeds we'll need to add to the buffer
  2727.         
  2728.         remainder = lineFeedInInches - FixMul( IntToFixed( FixedToInt(num144FractLineFeeds) ), oneOver144 );
  2729.         num216FractLineFeeds = FixedToInt( FixDiv( remainder, FixDiv( ff(1), ff(216) ) ) );
  2730.         
  2731.         // Send the line feed spacing commands and the line feeds necessary for the 1/144th's portion of the movement
  2732.         {
  2733.             short        numOne144ths = FixedToInt(num144FractLineFeeds);
  2734.             
  2735.             if (numOne144ths >= 99)    //    T => We can do a max. of 99/144 inch movement at a time
  2736.             {
  2737.                 //    Add the line feed spacing command to the buffer
  2738.                 *nextByte++ = kEscape;
  2739.                 *nextByte++ = 'T';
  2740.                 *nextByte++ = '9';
  2741.                 *nextByte++ = '9';
  2742.                 
  2743.                 // Update the count of the number of bytes added to the buffer
  2744.                 *bufferPos += 4;
  2745.         
  2746.                 do
  2747.                 {
  2748.                     *nextByte++ = kLineFeed;        // line feed
  2749.                     
  2750.                     // Update the count of the number of bytes added to the buffer
  2751.                     *bufferPos += 1;
  2752.         
  2753.                     numOne144ths -= 99;
  2754.                 }
  2755.                 while (numOne144ths >= 99);
  2756.             }
  2757.                 
  2758.             // Send remaining line feeds to finish off the 1/144th's portion of the movement
  2759.  
  2760.             if (numOne144ths > 0)    //    T => Still more movement
  2761.             {
  2762.                 *nextByte++ = kEscape;
  2763.                 *nextByte++ = 'T';
  2764.                 
  2765.                 NumToString(numOne144ths, aNumber);
  2766.                 if ( StrLength(aNumber) == 1 )
  2767.                 {
  2768.                     *nextByte++ = '0';
  2769.                     *nextByte++ = aNumber[1];
  2770.                 }
  2771.                 else
  2772.                 {
  2773.                     *nextByte++ = aNumber[1];
  2774.                     *nextByte++ = aNumber[2];
  2775.                 }
  2776.                 
  2777.                 // Add the linefeed character
  2778.                 *nextByte++ = kLineFeed;
  2779.  
  2780.                 // Update the count of the number of bytes added to the buffer
  2781.                 *bufferPos += 5;
  2782.             }
  2783.         }
  2784.         
  2785.         // Now send any spacing command for the remaining 1/216th portion of the movement if needed
  2786.         if (num216FractLineFeeds > 0)
  2787.         {
  2788.             NumToString(num216FractLineFeeds, aNumber);
  2789.             
  2790.             // Add the command to the buffer: <Esc> t <num line feeds>
  2791.             
  2792.             *nextByte++ = kEscape;
  2793.             *nextByte++ = 't';
  2794.             *nextByte = aNumber[1];
  2795.             
  2796.             // Bump the buffer byte count to account for these new characters
  2797.             *bufferPos += 3;
  2798.         }
  2799.  
  2800.         // We always handle the entire linefeed request so we can zero lineFeedSize
  2801.         *lineFeedSize = 0;
  2802.     }
  2803.  
  2804.     return(anErr);
  2805. }
  2806. /* SD_RasterLineFeed */
  2807.  
  2808.  
  2809.